def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def render_legend(mapfile, tile_uri):
m = mapnik.Map(1024, 2048)
# Load style XML
mapnik.load_map(m, mapfile, True)
# Obtain <Map> projection
prj = mapnik.Projection(m.srs)
# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
tileproj = GoogleProjection(20)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = prj.forward(mapnik.Coord(14.4503,50.0673))
c1 = prj.forward(mapnik.Coord(14.457,50.0678))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size_x = 1024
render_size_y = 1500
m.resize(render_size_x, render_size_y)
m.zoom_to_box(bbox)
m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size_x, render_size_y)
mapnik.render(m, im)
im.save(tile_uri, 'png256')
surface = cairo.SVGSurface('legend.svg', render_size_x, render_size_y)
mapnik.render(m, surface)
surface.finish()
def generate_map_tile(self, m, filename, z, x, y):
# Code taken from OSM generate_tiles.py
proj = GoogleProjection()
mprj = mapnik.Projection(m.srs)
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
l0 = proj.fromPixelToLL(p0, z);
l1 = proj.fromPixelToLL(p1, z);
c0 = mprj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = mprj.forward(mapnik.Coord(l1[0], l1[1]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
m.resize(256, 256)
m.zoom_to_box(bbox)
im = mapnik.Image(256, 256)
mapnik.render(m, im)
# See https://github.com/mapnik/mapnik/wiki/OutputFormats for output
# formats and special parameters. The default here is 32 bit PNG with 8
# bit per component and alpha channel.
if mapnik_version == 2:
im.save(str(filename), "png32")
else:
im.save(str(filename), "png")
def render_tile(self, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * TILE_SIZE, (y + 1) * TILE_SIZE)
p1 = ((x + 1) * TILE_SIZE, y * TILE_SIZE)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = TILE_SIZE
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
self.writer.write(x, y, z, im)
def serialize(xml, options):
try:
import mapnik2 as mapnik
except:
try:
import mapnik
except:
sys.exit(
color_text(
1,
'Error: saving xml requires Mapnik python bindings to be installed'
))
m = mapnik.Map(1, 1)
if options.from_string:
mapnik.load_map_from_string(m, xml, True)
else:
mapnik.load_map(m, xml, True)
if options.output:
mapnik.save_map(m, options.output)
else:
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 700:
print mapnik.save_map_to_string(m)
else:
sys.exit(
color_text(
1,
'Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file'
))
def serialize(xml, options):
try:
try:
import mapnik2 as mapnik
except ImportError:
import mapnik
except ImportError:
sys.exit(color_text(1, "Error: saving xml requires Mapnik python bindings to be installed"))
m = mapnik.Map(1, 1)
if options.from_string:
mapnik.load_map_from_string(m, xml, True)
else:
mapnik.load_map(m, xml, True)
if options.output:
mapnik.save_map(m, options.output)
else:
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 700:
print mapnik.save_map_to_string(m)
else:
sys.exit(
color_text(
1,
"Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file",
)
)
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
# Ensure the tile isn't blank before saving
if not im.tostring("png") == self.blankTileStr:
im.save(tile_uri, "png256")
# Return True if the tile was saved
return True
else:
return False
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
if(self.m.buffer_size < 128):
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def kml_hex_to_mapnik_color(key_color):
"""Convert a kml color string to a mapnik.Color"""
c = str(key_color)
a,b,g,r = tuple(map(lambda s: int(s, 16),(c[:2],c[2:4],c[4:6],c[6:])))
if mapnik.mapnik_version() >= 800:
pass #a *= 255
#print a,b,g,r
#return (r,g,b)
return mapnik.Color(r,g,b,a)
def GetFeatureInfo(self, params, querymethodname='query_point'):
m = self._buildMap(params)
if params['info_format'] == 'text/plain':
writer = TextFeatureInfo()
elif params['info_format'] == 'text/xml':
writer = XMLFeatureInfo()
if params['query_layers'] and params['query_layers'][0] == '__all__':
for layerindex, layer in enumerate(m.layers):
featureset = getattr(m, querymethodname)(layerindex, params['i'], params['j'])
features = featureset.features
if features:
writer.addlayer(layer.name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop in feat:
writer.addattribute(prop[0], prop[1])
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
for layerindex, layername in enumerate(params['query_layers']):
if layername in params['layers']:
# TODO - pretty sure this is bogus, we can't pull from m.layers by the layerindex of the
# 'query_layers' subset, need to pull from:
# self.mapfactory.layers[layername]
if m.layers[layerindex].queryable:
featureset = getattr(m, querymethodname)(layerindex, params['i'], params['j'])
features = featureset.features
if features:
writer.addlayer(m.layers[layerindex].name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop in feat:
writer.addattribute(prop[0], prop[1])
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
raise OGCException('Requested query layer "%s" is not marked queryable.' % layername, 'LayerNotQueryable')
else:
raise OGCException('Requested query layer "%s" not in the LAYERS parameter.' % layername)
return Response(params['info_format'], str(writer))
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
grid_uri = tile_uri.replace('.png', '.grid.json')
# new mapnik.Grid api, works like mapnik.Image
# with the exception that you can only render one
# layer to it with the mapnik.render_layer function
# create grid as same size as map/image
grid = mapnik.Grid(render_size, render_size)
# render a layer to that grid array
mapnik.render_layer(self.m, grid, layer=0, fields=['POP2005', 'NAME'])
# then encode the grid array as utf, resample to 1/4 the size, and dump features
grid_utf = grid.encode('utf', resolution=4, add_features=True)
# below is the old grid api - will be removed soon, don't use
#grid_utf = mapnik.render_grid(self.m,0,key='__id__',resolution=4,fields=['POP2005','NAME'])
# client code uses jsonp, so fake by wrapping in grid() callback
open(grid_uri, 'wb').write('grid(' + json.dumps(grid_utf) + ')')
def render_to_file(mapnik_map,output,format):
# get the full path for a users directory
if '~' in output:
output = os.path.expanduser(output)
# mapnik won't create directories so
# we have to make sure they exist first...
dirname = os.path.dirname(output)
if not os.path.exists(dirname):
os.makedirs(dirname)
# render out to the desired format
if format in ('png','png256','jpeg') or (hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 700):
try:
mapnik.render_to_file(mapnik_map,output,format)
except Exception, e:
return (False,e)
def render_image(start_time, end_time):
ll = (30.708, -27.414, 32.179, -25.652)
prj = mapnik.Projection("+init=epsg:900913")
c0 = prj.forward(mapnik.Coord(ll[0], ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2], ll[3]))
z = 3
imgx = 336 * z
imgy = 450 * z
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, "gpx-nolayer.xml")
db_params = dict(
dbname="gpx-merc",
user="******",
password="******",
host="localhost",
port=5433,
estimate_extent=False,
extent="3390650.221286806, -3163145.87245787, 3609898.596229789, -2956043.104540316",
)
lyr = Layer("points", "+init=epsg:900913")
db_params["table"] = (
"(select gps_points.geom as geom, gpx_files.gps_name as gps_name from gps_points INNER join gpx_files on gpx_files.id = gps_points.gpx_id where gps_points.timestamp >= '"
+ start_time
+ "' and gps_points.timestamp < '"
+ end_time
+ "') as points"
)
lyr.datasource = PostGIS(**db_params)
lyr.styles.append("points")
m.layers.append(lyr)
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save("frames/" + start_time + ".png", "png")
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
grid_uri = tile_uri.replace('.png','.grid.json')
# new mapnik.Grid api, works like mapnik.Image
# with the exception that you can only render one
# layer to it with the mapnik.render_layer function
# create grid as same size as map/image
grid = mapnik.Grid(render_size, render_size)
# render a layer to that grid array
mapnik.render_layer(self.m,grid,layer=0,fields=['POP2005','NAME'])
# then encode the grid array as utf, resample to 1/4 the size, and dump features
grid_utf = grid.encode('utf',resolution=4,add_features=True)
# below is the old grid api - will be removed soon, don't use
#grid_utf = mapnik.render_grid(self.m,0,key='__id__',resolution=4,fields=['POP2005','NAME'])
# client code uses jsonp, so fake by wrapping in grid() callback
open(grid_uri,'wb').write('grid(' + json.dumps(grid_utf) + ')')
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * TILES_SIZE, (y + 1) * TILES_SIZE)
p1 = ((x + 1) * TILES_SIZE, y * TILES_SIZE)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = TILES_SIZE
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
if FORMAT == 'grid':
grid = mapnik.Grid(render_size, render_size)
# mapnik.render_layer(self.m, grid, layer=64, fields=['name'])
for n, l in enumerate(self.m.layers):
if l.name != 'admin-012345678':
if 'name' in l.datasource.fields():
mapnik.render_layer(self.m,
grid,
layer=n,
fields=['name'])
utfgrid = grid.encode('utf', resolution=4)
f = open(tile_uri + '.' + FILE_EXTENSION, 'w')
f.write(json.dumps(utfgrid))
f.close()
else:
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri + '.' + FILE_EXTENSION, FORMAT)
def complexRun(image, stylesheet, extent, size):
mapfile = stylesheet
map_uri = image
imgx = size[0]
imgy = size[1]
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(extent[0],extent[2],extent[1],extent[3])
else:
bbox = mapnik.Envelope(extent[0],extent[2],extent[1],extent[3])
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
view = im.view(0,0,imgx,imgy) # x,y,width,height
view.save(map_uri,'png')
def complexRun(image, stylesheet, extent, size):
mapfile = stylesheet
map_uri = image
imgx = size[0]
imgy = size[1]
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(extent[0], extent[2], extent[1], extent[3])
else:
bbox = mapnik.Envelope(extent[0], extent[2], extent[1], extent[3])
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save(map_uri, 'png')
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
# start=time.time()
# p0 = (x * TILESIZE, (y + 1) * TILESIZE)
# p1 = ((x + 1) * TILESIZE, y * TILESIZE)
#
# # Convert to LatLong (EPSG:4326)
# l0 = self.tileproj.fromPixelToLL(p0, z);
# l1 = self.tileproj.fromPixelToLL(p1, z);
#
# # Convert to map projection (e.g. mercator co-ords EPSG:900913)
# c0 = self.prj.forward(mapnik2.Coord(l0[0],l0[1]))
# c1 = self.prj.forward(mapnik2.Coord(l1[0],l1[1]))
l0y, l0x = num2deg(x, y + 1, z)
l1y, l1x = num2deg(x + 1, y, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik2.Coord(l0x, l0y))
c1 = self.prj.forward(mapnik2.Coord(l1x, l1y))
# Bounding box for the tile
if hasattr(mapnik2,
'mapnik_version') and mapnik2.mapnik_version() >= 800:
bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik2.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = TILESIZE
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik2.Image(render_size, render_size)
# print("%f"%(time.time()-start))
# start=time.time()
mapnik2.render(self.m, im)
# print("%f"%(time.time()-start))
# start=time.time()
im.save(tile_uri, 'png256')
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * TILES_SIZE, (y + 1) * TILES_SIZE)
p1 = ((x + 1) * TILES_SIZE, y * TILES_SIZE)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = TILES_SIZE
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
if FORMAT == 'grid':
grid = mapnik.Grid(render_size, render_size)
# mapnik.render_layer(self.m, grid, layer=64, fields=['name'])
for n, l in enumerate(self.m.layers):
if l.name != 'admin-012345678':
if 'name' in l.datasource.fields():
mapnik.render_layer(self.m, grid, layer=n, fields=['name'])
utfgrid = grid.encode('utf', resolution=4)
f = open(tile_uri + '.' + FILE_EXTENSION, 'w')
f.write(json.dumps(utfgrid))
f.close()
else:
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri + '.' + FILE_EXTENSION, FORMAT)
def ogc_filter_to_mapnik(ogc_filter):
if hasattr(ogc_filter,'PropertyIsGreaterThan'):
prop = ogc_filter.PropertyIsGreaterThan
operator = '>'
#cql = "[%s] > %s" % (prop.PropertyName,prop.Literal)
elif hasattr(ogc_filter,'PropertyIsLessThan'):
prop = ogc_filter.PropertyIsLessThan
operator = '<'
elif hasattr(ogc_filter,'PropertyIsEqualTo'):
prop = ogc_filter.PropertyIsEqualTo
operator = '='
elif hasattr(ogc_filter,'PropertyIsNotEqualTo'):
prop = ogc_filter.PropertyIsNotEqualTo
operator = '!='
if is_number(prop.Literal.text):
cql = "[%s] %s %s" % (prop.PropertyName,operator,prop.Literal)
else:
cql = "[%s] %s '%s'" % (prop.PropertyName,operator,prop.Literal.text)
if mapnik.mapnik_version() >= 800:
return mapnik.Expression(str(cql))
else:
return mapnik.Filter(str(cql))
def ogc_filter_to_mapnik(ogc_filter):
if hasattr(ogc_filter,'PropertyIsGreaterThan'):
prop = ogc_filter.PropertyIsGreaterThan
operator = '>'
#cql = "[%s] > %s" % (prop.PropertyName,prop.Literal)
elif hasattr(ogc_filter,'PropertyIsLessThan'):
prop = ogc_filter.PropertyIsLessThan
operator = '<'
elif hasattr(ogc_filter,'PropertyIsEqualTo'):
prop = ogc_filter.PropertyIsEqualTo
operator = '='
elif hasattr(ogc_filter,'PropertyIsNotEqualTo'):
prop = ogc_filter.PropertyIsNotEqualTo
operator = '!='
if is_number(prop.Literal.text):
cql = "[%s] %s %s" % (prop.PropertyName,operator,prop.Literal)
else:
cql = "[%s] %s '%s'" % (prop.PropertyName,operator,prop.Literal.text)
if mapnik.mapnik_version() >= 800:
return mapnik.Expression(str(cql))
else:
return mapnik.Filter(str(cql))
def generate_map_tile(self, m, filename, z, x, y):
# Code taken from OSM generate_tiles.py
proj = GoogleProjection()
mprj = mapnik.Projection(m.srs)
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
l0 = proj.fromPixelToLL(p0, z);
l1 = proj.fromPixelToLL(p1, z);
c0 = mprj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = mprj.forward(mapnik.Coord(l1[0], l1[1]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
m.resize(256, 256)
m.zoom_to_box(bbox)
im = mapnik.Image(256, 256)
mapnik.render(m, im)
im.save(str(filename), "png256")
def render_metatile(self, metatile:map_utils.MetaTile) -> Dict[map_utils.Tile, bool]:
# get LatLong (EPSG:4326)
l0 = metatile.coords[0]
l1 = metatile.coords[1]
# this is the only time where we convert manually into WebMerc
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
self.m.resize(self.image_size, self.image_size)
self.m.zoom_to_box(bbox)
if self.m.buffer_size < 128:
self.m.buffer_size = 128
bail_out = True
start = time.perf_counter()
if not self.opts.dry_run:
im = mapnik.Image(self.image_size, self.image_size)
# Render image with default Agg renderer
debug('[%s] rende...', self.pid)
# TODO: handle exception, send back into queue
mapnik.render(self.m, im)
debug('[%s] ...ring!', self.pid)
mid = time.perf_counter()
# TODO: all this is on a single tile, not a metatile
# converting to png256 is the fastest I have found so far:
# python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring("png256")'
# 100 loops, best of 3: 7.72 msec per loop
# tostring() looks nice, but I can't rebuild a mapnik.Image from it :(
# python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring()'
# 100000 loops, best of 3: 13.8 usec per loop
# python3.6 -m timeit -s 'import mapnik, bz2; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'c = bz2.BZ2Compressor(); c.compress(im.tostring()); data = c.flush()'
# 10 loops, best of 3: 20.3 msec per loop
# python3.6 -m timeit -s 'import mapnik, gzip; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = gzip.compress(im.tostring())'
# 10 loops, best of 3: 27.7 msec per loop
# python3.6 -s -m timeit -s 'import mapnik, lzma; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' "c = lzma.LZMACompressor(); c.compress(im.tostring()); data = c.flush()"
# 10 loops, best of 3: 92 msec per loop
# TODO:
# but bz2 compresses the best, 52714 png vs 49876 bzip vs 70828 gzip vs 53032 lzma
if not self.opts.store_thread:
# metatile will go in a non-marshaling queue, no need tostring() it
metatile.im = im
else:
metatile.im = im.tostring('png256')
end = time.perf_counter()
else:
debug('[%s] thumbtumbling', self.pid)
time.sleep(randint(0, 30) / 10)
mid = time.perf_counter()
end = time.perf_counter()
metatile.render_time = mid - start
metatile.serializing_time = end - mid
bail_out = False
debug("[%s] putting %r", self.pid, metatile)
self.output.put(metatile)
debug("[%s] put! (%d)", self.pid, self.output.qsize())
if not self.opts.store_thread and self.output.qsize() > 0:
# NOTE: mypy complains here that Item "Process" of "Union[Process, StormBringer]" has no attribute "single_step"
# the solutions are ugly, so I'm leaving it as that
self.store_thread.single_step()
return bail_out
import sys, os
# Set up projections
# spherical mercator (most common target map projection of osm data imported with osm2pgsql)
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'
)
# long/lat in degrees, aka ESPG:4326 and "WGS 84"
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# can also be constructed as:
#longlat = mapnik.Projection('+init=epsg:4326')
# ensure minimum mapnik version
if not hasattr(mapnik,
'mapnik_version') and not mapnik.mapnik_version() >= 600:
raise SystemExit('This script requires Mapnik >=0.6.0)')
if __name__ == "__main__":
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "stylesheet/osm_style.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
#bounds = (-6.5, 49.5, 2.1, 59)
bounds = (34.129, 30.9894, 34.6893, 31.7258)
def render_map(mapfile):
#A4
#filename = 'export_A4'
#render_size_x = 842
#render_size_y = 595
#A3
#filename = 'export_A3'
#render_size_x = 1191
#render_size_y = 842
#A2
#filename = 'export_A2'
#render_size_x = 1684
#render_size_y = 1191
#A1
#filename = 'export_A1'
#render_size_x = 2384
#render_size_y = 1684
#A0
filename = 'export_A0'
render_size_x = 3370
render_size_y = 2384
#A-1
#filename = 'export_A-1'
#render_size_x = 4768
#render_size_y = 3370
#A-2
#filename = 'export_A-2'
#render_size_x = 6740
#render_size_y = 4768
m = mapnik.Map(render_size_x, render_size_y)
# Load style XML
mapnik.load_map(m, mapfile, True)
# Obtain <Map> projection
prj = mapnik.Projection(m.srs)
# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
tileproj = GoogleProjection(20)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = prj.forward(mapnik.Coord(14.33, 50.05))
c1 = prj.forward(mapnik.Coord(14.53, 50.14))
#filename = filename + '_BIG'
#c0 = prj.forward(mapnik.Coord(14.25,49.95))
#c1 = prj.forward(mapnik.Coord(14.68,50.16))
# Bounding box for the tile
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
m.resize(render_size_x, render_size_y)
m.zoom_to_box(bbox)
m.buffer_size = 128
# Render image with default Agg renderer
#im = mapnik.Image(render_size_x, render_size_y)
#mapnik.render(m, im)
#im.save('export.png', 'png256')
#surface = cairo.PDFSurface(filename + '.pdf', render_size_x, render_size_y)
#mapnik.render(m, surface)
surface = cairo.PSSurface(filename + '.ps', render_size_x, render_size_y)
surface.dsc_comment("%%Title: Cyklisticka mapa prahy")
surface.dsc_comment("%%Copyright: CC-BY-SA")
mapnik.render(m, surface)
#surface = cairo.SVGSurface(filename + '.svg', render_size_x, render_size_y)
#mapnik.render(m, surface)
surface.finish()
###
# center of the image
label_x = xmin + ((xmax - xmin) / 2)
# bottom of the image
label_y = ymin + ((ymax - ymin) / 30)
# create PointDatasource
pds = mapnik2.PointDatasource()
# place scale at the bottom-center of the map
pds.add_point(label_x, label_y, 'Name', "Scale: 1:" + str(m.scale_denominator()))
# create label symbolizers
if mapnik2.mapnik_version() >= 800:
text = mapnik2.TextSymbolizer(mapnik2.Expression('[Name]'),'DejaVu Sans Bold',12,mapnik2.Color('black'))
else:
text = mapnik2.TextSymbolizer('Name','DejaVu Sans Bold',12,mapnik2.Color('black'))
s3 = mapnik2.Style()
r3 = mapnik2.Rule()
r3.symbols.append(text)
s3.rules.append(r3)
lyr3 = mapnik2.Layer('Memory Datasource')
lyr3.datasource = pds
lyr3.styles.append('Style')
m.layers.append(lyr3)
m.append_style('Style',s3)
from PyQt4.QtGui import *
from PyQt4.QtCore import *
try:
import mapnik2 as mapnik
except ImportError:
import mapnik
# repair compatibility with mapnik2 development series
if hasattr(mapnik,'Box2d'):
mapnik.Envelope = mapnik.Box2d
MAPNIK_VERSION = None
if hasattr(mapnik,'mapnik_version'):
MAPNIK_VERSION = mapnik.mapnik_version()
import sync
# Use pdb for debugging
#import pdb
# These lines allow you to set a breakpoint in the app
#pyqtRemoveInputHook()
#pdb.set_trace()
#TODO - support for Composer
# http://trac.osgeo.org/qgis/changeset/13361
try:
from pygments import highlight
# A4 Landscape
imgx_cm = 20.0
imgy_cm = 14.0
img_dpi = 300.0
mapnik_scale_factor = img_dpi / 92.
imgx = int(imgx_cm * img_dpi / 2.54)
imgy = int(imgy_cm * img_dpi / 2.54)
print "generating map...."
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,xmlmapfile)
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")
c0 = prj.forward(mapnik.Coord(ll[0],ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2],ll[3]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y,c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y,c1.x,c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im,mapnik_scale_factor)
view = im.view(0,0,imgx,imgy) # x,y,width,height
view.save(map_uri,'png')
print "done - image stored as %s" % map_uri
except:
import mapnik
import sys, os
# Set up projections
# spherical mercator (most common target map projection of osm data imported with osm2pgsql)
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')
# long/lat in degrees, aka ESPG:4326 and "WGS 84"
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# can also be constructed as:
#longlat = mapnik.Projection('+init=epsg:4326')
# ensure minimum mapnik version
if not hasattr(mapnik,'mapnik_version') and not mapnik.mapnik_version() >= 600:
raise SystemExit('This script requires Mapnik >=0.6.0)')
if __name__ == "__main__":
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "osm.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
bounds = (-6.5, 49.5, 2.1, 59)
#---------------------------------------------------
except:
import mapnik
import sys, os
# Set up projections
# spherical mercator (most common target map projection of osm data imported with osm2pgsql)
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')
# long/lat in degrees, aka ESPG:4326 and "WGS 84"
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# can also be constructed as:
#longlat = mapnik.Projection('+init=epsg:4326')
# ensure minimum mapnik version
if not hasattr(mapnik,'mapnik_version') and not mapnik.mapnik_version() >= 600:
raise SystemExit('This script requires Mapnik >=0.6.0)')
if __name__ == "__main__":
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "/home/simon/osm/GWR/cantonal/namestats_road_ag.xml"
map_uri = "/var/www/qa/ch-roads/namestats_road_ag.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
bounds = (7.7124,47.1346,8.4595,47.6247)
#---------------------------------------------------
#except:
# import mapnik
import sys, os
# Set up projections
# spherical mercator (most common target map projection of osm data imported with osm2pgsql)
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')
# long/lat in degrees, aka ESPG:4326 and "WGS 84"
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# can also be constructed as:
#longlat = mapnik.Projection('+init=epsg:4326')
# ensure minimum mapnik version
if not hasattr(mapnik,'mapnik_version') and not mapnik.mapnik_version() >= 600:
raise SystemExit('This script requires Mapnik >=0.6.0)')
print "Mapnik Version: ",mapnik.mapnik_version(),"\n"
if __name__ == "__main__":
map_name = "detail"
#---------------------------------------------------
# Change this to the bounding box you want
#
bounds = (9.932, 53.538, 10.01, 53.56)
dpi=300
# 8cm auf der Karte sind 1km in der Natur ; 1km=1000m=100000cm; 4/10000
massstab=8.0/100000.0 # 1cm
#---------------------------------------------------
# Change this to the bounding box you want
#
#ll = (-5.2, 41.4, 10.16, 46.2)
#ll = (1.393547058105469, 43.56610697474913, 1.429810523986817, 43.58131079720606) #reynerie
#ll = (1.406988241528325, 43.56730920511517, 1.461919882153325, 43.60237411394007) #ponts
#ll = (1.359014509180042, 43.59232959871322, 1.404848096826527, 43.62626162214223) #tournefeuille (rocades)
ll = args.bbox
#---------------------------------------------------
z = args.zoom
imgx = 500 * z
imgy = 1000 * z
m = mapnik2.Map(imgx, imgy)
mapnik2.load_map(m, args.mapfile)
prj = mapnik2.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"
)
c0 = prj.forward(mapnik2.Coord(ll[0], ll[1]))
c1 = prj.forward(mapnik2.Coord(ll[2], ll[3]))
if hasattr(mapnik2, 'mapnik_version') and mapnik2.mapnik_version() >= 800:
bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik2.Envelope(c0.x, c0.y, c1.x, c1.y)
m.zoom_to_box(bbox)
im = mapnik2.Image(imgx, imgy)
mapnik2.render(m, im)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save(map_uri, 'png')
def toposmInfo():
print "Using mapnik version:", mapnik.mapnik_version()
print "Has Cairo:", mapnik.has_cairo()
print "Fonts:"
for face in mapnik.FontEngine.face_names():
print "\t", face
def render_map(mapfile):
#A4
#filename = 'export_A4'
#render_size_x = 842
#render_size_y = 595
#A3
#filename = 'export_A3'
#render_size_x = 1191
#render_size_y = 842
#A2
#filename = 'export_A2'
#render_size_x = 1684
#render_size_y = 1191
#A1
#filename = 'export_A1'
#render_size_x = 2384
#render_size_y = 1684
#A0
filename = 'export_A0'
render_size_x = 3370
render_size_y = 2384
#A-1
#filename = 'export_A-1'
#render_size_x = 4768
#render_size_y = 3370
#A-2
#filename = 'export_A-2'
#render_size_x = 6740
#render_size_y = 4768
m = mapnik.Map(render_size_x, render_size_y)
# Load style XML
mapnik.load_map(m, mapfile, True)
# Obtain <Map> projection
prj = mapnik.Projection(m.srs)
# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
tileproj = GoogleProjection(20)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = prj.forward(mapnik.Coord(14.33,50.05))
c1 = prj.forward(mapnik.Coord(14.53,50.14))
#filename = filename + '_BIG'
#c0 = prj.forward(mapnik.Coord(14.25,49.95))
#c1 = prj.forward(mapnik.Coord(14.68,50.16))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
m.resize(render_size_x, render_size_y)
m.zoom_to_box(bbox)
m.buffer_size = 128
# Render image with default Agg renderer
#im = mapnik.Image(render_size_x, render_size_y)
#mapnik.render(m, im)
#im.save('export.png', 'png256')
#surface = cairo.PDFSurface(filename + '.pdf', render_size_x, render_size_y)
#mapnik.render(m, surface)
surface = cairo.PSSurface(filename + '.ps', render_size_x, render_size_y)
surface.dsc_comment ("%%Title: Cyklisticka mapa prahy")
surface.dsc_comment ("%%Copyright: CC-BY-SA")
mapnik.render(m, surface)
#surface = cairo.SVGSurface(filename + '.svg', render_size_x, render_size_y)
#mapnik.render(m, surface)
surface.finish()
import sys, os
import mapnik2
import cairo
import json
import argparse
import tempfile
import shutil
from globalmaptiles import GlobalMercator
from tileloader import GoogleTileLoader, TMSTileLoader, FTileLoader
# sys.stdout.write("areas: '" + str(areas) + "'\n")
# sys.stdout.write("pois: '" + str(areas) + "'\n")
# sys.exit(0)
# ensure minimum mapnik version
if not hasattr(mapnik2, "mapnik_version") and not mapnik2.mapnik_version() >= 600:
raise SystemExit("This script requires Mapnik >=0.6.0)")
# Google bounds toString() gives following string:
# ((61.477925877956785, 21.768811679687474), (61.488948601502614, 21.823743320312474))
def googleBoundsToBox2d(google_bounds):
parts = google_bounds.split(",")
strip_str = "() "
min_lat = float(parts[0].strip(strip_str))
min_lng = float(parts[1].strip(strip_str))
max_lat = float(parts[2].strip(strip_str))
max_lng = float(parts[3].strip(strip_str))
return (min_lng, min_lat, max_lng, max_lat)
class TileSourceParser:
def render_metatile(
self, metatile: map_utils.MetaTile) -> Dict[map_utils.Tile, bool]:
# get LatLong (EPSG:4326)
l0 = metatile.coords[0]
l1 = metatile.coords[1]
# this is the only time where we convert manually into WebMerc
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
image_size = self.opts.tile_size * min(self.metatile_size, 2**
metatile.z)
self.m.resize(image_size, image_size)
self.m.zoom_to_box(bbox)
if self.m.buffer_size < 128:
self.m.buffer_size = 128
bail_out = True
start = time.perf_counter()
if not self.opts.dry_run:
im = mapnik.Image(image_size, image_size)
# Render image with default Agg renderer
debug('[%s] rende...', self.name)
# TODO: handle exception, send back into queue
mapnik.render(self.m, im)
debug('[%s] ...ring!', self.name)
mid = time.perf_counter()
# TODO: all this is on a single tile, not a metatile
# converting to png256 is the fastest I have found so far:
# python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring("png256")'
# 100 loops, best of 3: 7.72 msec per loop
# tostring() looks nice, but I can't rebuild a mapnik.Image from it :(
# python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring()'
# 100000 loops, best of 3: 13.8 usec per loop
# python3.6 -m timeit -s 'import mapnik, bz2; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'c = bz2.BZ2Compressor(); c.compress(im.tostring()); data = c.flush()'
# 10 loops, best of 3: 20.3 msec per loop
# python3.6 -m timeit -s 'import mapnik, gzip; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = gzip.compress(im.tostring())'
# 10 loops, best of 3: 27.7 msec per loop
# python3.6 -s -m timeit -s 'import mapnik, lzma; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' "c = lzma.LZMACompressor(); c.compress(im.tostring()); data = c.flush()"
# 10 loops, best of 3: 92 msec per loop
# TODO:
# but bz2 compresses the best, 52714 png vs 49876 bzip vs 70828 gzip vs 53032 lzma
if not self.opts.store_thread:
# metatile will go in a non-marshaling queue, no need tostring() it
metatile.im = im
else:
metatile.im = im.tostring('png256')
end = time.perf_counter()
else:
debug('[%s] thumbtumbling', self.name)
time.sleep(randint(0, 30) / 10)
mid = time.perf_counter()
end = time.perf_counter()
metatile.render_time = mid - start
metatile.serializing_time = end - mid
bail_out = False
debug("[%s] putting %r", self.name, metatile)
self.output.put(metatile)
debug("[%s] put! (%d)", self.name, self.output.qsize())
if not self.opts.store_thread and self.output.qsize() > 0:
# NOTE: mypy complains here that Item "Process" of "Union[Process, StormBringer]" has no attribute "single_step"
# the solutions are ugly, so I'm leaving it as that
self.store_thread.single_step()
return bail_out
def toposmInfo():
print "Using mapnik version:", mapnik.mapnik_version()
print "Has Cairo:", mapnik.has_cairo()
print "Fonts:"
for face in mapnik.FontEngine.face_names():
print "\t", face
# A4 Landscape
imgx_cm = 20.0
imgy_cm = 14.0
img_dpi = 300.0
mapnik_scale_factor = img_dpi / 92.0
imgx = int(imgx_cm * img_dpi / 2.54)
imgy = int(imgy_cm * img_dpi / 2.54)
print "generating map...."
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, xmlmapfile)
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"
)
c0 = prj.forward(mapnik.Coord(ll[0], ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2], ll[3]))
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im, mapnik_scale_factor)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save(map_uri, "png")
print "done - image stored as %s" % map_uri
def render_metatile(self, metatile):
z = metatile.z
x = metatile.x
y = metatile.y
# TODO: move all this somewhere else
# Calculate pixel positions of bottom-left & top-right
p0 = (x * self.tile_size, (y + self.metatile_size) * self.tile_size)
p1 = ((x + self.metatile_size) * self.tile_size, y * self.tile_size)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
self.m.resize(self.image_size, self.image_size)
self.m.zoom_to_box(bbox)
if self.m.buffer_size < 128:
self.m.buffer_size = 128
# we must decide wether to render the subtiles/children of this tile
render_children = {child: False for child in metatile.children()}
if not self.opts.dry_run:
# Render image with default Agg renderer
start = time.perf_counter()
im = mapnik.Image(self.image_size, self.image_size)
try:
mapnik.render(self.m, im)
except RuntimeError as e:
exception("%r: %s", metatile, e)
else:
mid = time.perf_counter()
# save the image, splitting it in the right amount of tiles
for tile in metatile.tiles:
i, j = tile.meta_index
# TODO: Tile.meta_pixel_coords
img = im.view(i * self.tile_size, j * self.tile_size,
self.tile_size, self.tile_size)
tile.data = img.tostring('png256')
# TODO: move to Tile
is_empty = map_utils.is_empty(tile.data)
if not is_empty or self.opts.empty == 'write':
self.backend.store(tile)
# at least something to render. note that if we're
# rendering only one tile (either metatile_size == 1
# or z == 0), i, j can only be == 0. this matches
# the situation further down
render_children[metatile.child(tile)] = True
else:
if self.opts.empty == 'skip':
# empty tile, skip
debug("%r: empty" % tile)
continue
# TODO: else?
self.backend.commit()
end = time.perf_counter()
info("%r: %f, %f" % (metatile, mid - start, end - mid))
else:
# simulate some work
time.sleep(randint(0, 30) / 10)
for child in metatile.children():
if random() <= 0.75 or 2**metatile.z < self.opts.metatile_size:
render_children[child] = True
return render_children
def ogc_filter_to_mapnik(ogc_filter):
cql = _ogc_filter_to_expression(ogc_filter.getchildren()[0])
if mapnik.mapnik_version() >= 800:
return mapnik.Expression(str(cql))
else:
return mapnik.Filter(str(cql))
HAS_MAPNIK = True
except ImportError:
try:
import mapnik
HAS_MAPNIK = True
except ImportError:
HAS_MAPNIK = False
MAPNIK_AUTO_IMAGE_SUPPORT = None
MAPNIK_VERSION = None
# if mapnik is actually installed we attempt
# to benefit from knowing its version
if HAS_MAPNIK:
if hasattr(mapnik,'mapnik_version'):
MAPNIK_VERSION = mapnik.mapnik_version()
# note, bugs in 0.7.0 require *_pattern_symbolizer image type,width,height to be specified
# fixed in 0.7.1 - http://trac.mapnik.org/ticket/508
if MAPNIK_VERSION >= 701:
MAPNIK_AUTO_IMAGE_SUPPORT = True
if not HAS_PIL:
warn = 'Warning: PIL (Python Imaging Library) is required for proper handling of image symbolizers when using JPEG format images or not running Mapnik >=0.7.0\n'
sys.stderr.write(warn)
DEFAULT_ENCODING = 'utf-8'
try:
import lxml.etree as ElementTree
from lxml.etree import Element, tostring
except ImportError:
# center of the image
label_x = xmin + ((xmax - xmin) / 2)
# bottom of the image
label_y = ymin + ((ymax - ymin) / 30)
# create PointDatasource
pds = mapnik2.PointDatasource()
# place scale at the bottom-center of the map
pds.add_point(label_x, label_y, 'Name',
"Scale: 1:" + str(m.scale_denominator()))
# create label symbolizers
if mapnik2.mapnik_version() >= 800:
text = mapnik2.TextSymbolizer(mapnik2.Expression('[Name]'),
'DejaVu Sans Bold', 12,
mapnik2.Color('black'))
else:
text = mapnik2.TextSymbolizer('Name', 'DejaVu Sans Bold', 12,
mapnik2.Color('black'))
s3 = mapnik2.Style()
r3 = mapnik2.Rule()
r3.symbols.append(text)
s3.rules.append(r3)
lyr3 = mapnik2.Layer('Memory Datasource')
lyr3.datasource = pds
lyr3.styles.append('Style')
def ogc_filter_to_mapnik(ogc_filter):
cql = _ogc_filter_to_expression(ogc_filter.getchildren()[0])
if mapnik.mapnik_version() >= 800:
return mapnik.Expression(str(cql))
else:
return mapnik.Filter(str(cql))
