def test_render_mvt_merc_nested_layers():
m = mapnik.Map(512, 512)
mapnik.load_map(m, '../data-visual/styles/nested-layers-1.xml')
mvt = mapnik.VectorTileMerc(0, 0, 0)
im2 = mapnik.Image(m.width, m.height)
m.zoom_to_box(mvt.extent)
mapnik.render(m, im2)
actual2 = 'images/mvt/nested_layers.classic.actual.png'
expected2 = 'images/mvt/nested_layers.classic.expected.png'
im2.save(actual2, 'png32')
eq_(compare_file_size(actual2, expected2, 100), True)
mvt_buffer = mapnik.create_mvt_merc(m,
mvt.x, mvt.y, mvt.z)
# Check number of layers of the MVT
vti = mapnik.VectorTileInfo()
vti.parse_from_string(mvt_buffer)
eq_(vti.layers_size(), 2);
mapnik.merge_compressed_buffer(mvt, mvt_buffer)
m = mapnik.Map(512, 512)
# Load a version of the style with no datasources
mapnik.load_map(m, 'styles/nested-layers-1.xml')
im = mapnik.Image(m.width, m.height)
mapnik.render_mvt_merc(mvt, m, im)
actual = 'images/mvt/nested_layers.mvt.actual.png'
im.save(actual, 'png32')
expected = 'images/mvt/nested_layers.mvt.expected.png'
eq_(compare_file_size(actual, expected, 100), True)
def test_zoom_all_will_work_with_max_extent():
m = mapnik.Map(512, 512)
mapnik.load_map(m, '../data/good_maps/wgs842merc_reprojection.xml')
merc_bounds = mapnik.Box2d(-20037508.34, -20037508.34, 20037508.34,
20037508.34)
m.maximum_extent = merc_bounds
m.zoom_all()
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 test_style_level_comp_op():
m = mapnik.Map(256, 256)
mapnik.load_map(m, '../data/good_maps/style_level_comp_op.xml')
m.zoom_all()
successes = []
fails = []
for name in mapnik.CompositeOp.names:
# find_style returns a copy of the style object
style_markers = m.find_style("markers")
style_markers.comp_op = getattr(mapnik.CompositeOp, name)
# replace the original style with the modified one
replace_style(m, "markers", style_markers)
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
actual = '/tmp/mapnik-style-comp-op-' + name + '.png'
expected = 'images/style-comp-op/' + name + '.png'
im.save(actual)
if not os.path.exists(expected):
print 'generating expected test image: %s' % expected
im.save(expected)
expected_im = mapnik.Image.open(expected)
# compare them
if im.tostring() == expected_im.tostring():
successes.append(name)
else:
fails.append('failed comparing actual (%s) and expected(%s)' % (actual,'tests/python_tests/'+ expected))
fail_im = side_by_side_image(expected_im, im)
fail_im.save('/tmp/mapnik-style-comp-op-' + name + '.fail.png')
eq_(len(fails), 0, '\n'+'\n'.join(fails))
def test_style_level_comp_op():
m = mapnik.Map(256, 256)
mapnik.load_map(m, "../data/good_maps/style_level_comp_op.xml")
m.zoom_all()
successes = []
fails = []
for name in mapnik.CompositeOp.names:
# find_style returns a copy of the style object
style_markers = m.find_style("markers")
style_markers.comp_op = getattr(mapnik.CompositeOp, name)
# replace the original style with the modified one
replace_style(m, "markers", style_markers)
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
actual = "/tmp/mapnik-style-comp-op-" + name + ".png"
expected = "images/style-comp-op/" + name + ".png"
im.save(actual, "png32")
if not os.path.exists(expected) or os.environ.get("UPDATE"):
print "generating expected test image: %s" % expected
im.save(expected, "png32")
expected_im = mapnik.Image.open(expected)
# compare them
if im.tostring("png32") == expected_im.tostring("png32"):
successes.append(name)
else:
fails.append(
"failed comparing actual (%s) and expected(%s)" % (actual, "tests/python_tests/" + expected)
)
fail_im = side_by_side_image(expected_im, im)
fail_im.save("/tmp/mapnik-style-comp-op-" + name + ".fail.png", "png32")
eq_(len(fails), 0, "\n" + "\n".join(fails))
def renderTile(self, width, height, srs, coord):
"""
"""
if self.mapnik is None:
self.mapnik = mapnik.Map(0, 0)
mapnik.load_map(self.mapnik, str(self.mapfile))
nw = self.layer.projection.coordinateLocation(coord)
se = self.layer.projection.coordinateLocation(coord.right().down())
ul = self.mercator.locationProj(nw)
lr = self.mercator.locationProj(se)
self.mapnik.width = width
self.mapnik.height = height
self.mapnik.zoom_to_box(mapnik.Box2d(ul.x, ul.y, lr.x, lr.y))
# create grid as same size as map/image
grid = mapnik.Grid(width, height)
# render a layer to that grid array
mapnik.render_layer(self.mapnik, grid, layer=self.layer_index, fields=self.fields)
# then encode the grid array as utf, resample to 1/scale the size, and dump features
grid_utf = grid.encode('utf', resolution=self.scale, features=True)
if self.wrapper is None:
return SaveableResponse(json.dumps(grid_utf))
else:
return SaveableResponse(self.wrapper + '(' + json.dumps(grid_utf) + ')')
def test_can_parse_xml_with_deprecated_properties():
default_logging_severity = mapnik.logger.get_severity()
mapnik.logger.set_severity(getattr(mapnik.severity_type, "None"))
files_with_deprecated_props = glob.glob("../data/deprecated_maps/*.xml")
failures = []
for filename in files_with_deprecated_props:
try:
m = mapnik.Map(512, 512)
strict = True
mapnik.load_map(m, filename, strict)
base_path = os.path.dirname(filename)
mapnik.load_map_from_string(
m,
open(
filename,
'rb').read(),
strict,
base_path)
except RuntimeError as e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e) \
and not 'could not connect' in str(e):
failures.append(
'Failed to load valid map %s (%s)' %
(filename, e))
eq_(len(failures), 0, '\n' + '\n'.join(failures))
mapnik.logger.set_severity(default_logging_severity)
def test_zoom_all_will_work_with_max_extent():
m = mapnik.Map(512, 512)
mapnik.load_map(m, '../data/good_maps/wgs842merc_reprojection.xml')
merc_bounds = mapnik.Box2d(-20037508.34, -
20037508.34, 20037508.34, 20037508.34)
m.maximum_extent = merc_bounds
m.zoom_all()
def __init__(self, name, style_sheets, commands,
buffer_size=0,
base_path=None,
default_scale=None):
TermNode.__init__(self, name)
assert isinstance(style_sheets, list)
assert isinstance(commands, list)
if len(commands) != len(style_sheets) - 1:
raise InvalidCommandNumber(
'len(commands) should be len(style_sheets) - 1')
self._default_scale = default_scale
self._commands = commands
self._maps = list()
for style_sheet in style_sheets:
map = mapnik.Map(32, 32)
filename = os.path.abspath(style_sheet)
if base_path is None:
base_path = os.path.dirname(filename)
mapnik.load_map(map, filename, True, base_path)
map.buffer_size = buffer_size
self._maps.append(map)
def test_hit_grid():
import os
from itertools import groupby
def rle_encode(l):
""" encode a list of strings with run-length compression """
return ["%d:%s" % (len(list(group)), name) for name, group in groupby(l)]
m = mapnik.Map(256,256);
mapnik.load_map(m,'../data/good_maps/agg_poly_gamma_map.xml');
m.zoom_all()
join_field = 'NAME'
fg = [] # feature grid
for y in range(0, 256, 4):
for x in range(0, 256, 4):
featureset = m.query_map_point(0,x,y)
added = False
for feature in featureset.features:
fg.append(feature[join_field])
added = True
if not added:
fg.append('')
hit_list = '|'.join(rle_encode(fg))
eq_(hit_list[:16],'730:|2:Greenland')
eq_(hit_list[-12:],'1:Chile|812:')
def _init_mapnik(self, projection):
projection = '+init=%s' % projection.lower()
mapper = mapnik.Map(32, 32, projection)
mapnik.load_map(mapper, self._theme)
self._proj = mapnik.Projection(projection)
mapper.buffer_size = self._buffer_size
return mapper
def run(self):
self.mapnik_map = mapnik.Map(self.width, self.height)
mapnik.load_map(self.mapnik_map, self.config, True)
self.map_projection = mapnik.Projection(self.mapnik_map.srs)
self.tile_projection = projections.GoogleProjection()
while True:
tile_parameters = None
# Try to fetch a tile from any queue
for tile_queue in self.tile_queues:
try:
tile_parameters = tile_queue.get_nowait()
break
except Queue.Empty:
pass
# Couldn't get tile parameters from any queue--all done
if not tile_parameters:
return
# Skip rendering existing tiles
if self.skip_existing:
filename = tile_parameters[0]
if os.path.exists(filename):
print 'Skipping %s' % (filename)
tile_queue.task_done()
continue
self.render(*tile_parameters)
tile_queue.task_done()
def test_non_member_known_attributes():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/extra_known_map_attributes.xml')
attr = m.extra_attributes
eq_(len(attr),2)
eq_(attr['font-directory'],'.')
eq_(attr['minimum-version'],'0.0.0')
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 watcher(self):
failed = 0
while 1:
if not self.modified == os.path.getmtime(self._mapfile):
self._locked = True
time.sleep(self.watch_interval/2.0)
self._log.info('Mapfile **changed**, reloading... ')
try:
self._mapnik_map = mapnik.Map(self.size,self.size)
if self._mapfile.endswith('.xml'):
mapnik.load_map(self._mapnik_map, self._mapfile)
elif self._mapfile.endswith('.mml'):
from cascadenik import load_map as load_mml
load_mml(self._mapnik_map, self._mapfile)
self.msg('Mapfile successfully reloaded from %s' % self._mapfile)
if not is_merc(self._mapnik_map.srs):
self._mapnik_map.srs = MERC_PROJ4
self.msg('Map is not in spherical mercator, so setting that projection....')
failed = 0
except Exception, E:
failed += 1
again = self.watch_interval*2
self.msg('Failed to reload mapfile, will try again in %s seconds:\n%s' % (again,E))
time.sleep(again)
self.modified = os.path.getmtime(self._mapfile)
self._locked = False
else:
time.sleep(self.watch_interval)
if failed > self.max_failures:
self.msg('Giving up on mapfile change watching thread...')
break
def renderTile(self, width, height, srs, coord):
"""
"""
if self.mapnik is None:
self.mapnik = mapnik.Map(0, 0)
mapnik.load_map(self.mapnik, str(self.mapfile))
# buffer as fraction of tile size
buffer = float(self.buffer) / 256
nw = self.layer.projection.coordinateLocation(coord.left(buffer).up(buffer))
se = self.layer.projection.coordinateLocation(coord.right(1 + buffer).down(1 + buffer))
ul = self.mercator.locationProj(nw)
lr = self.mercator.locationProj(se)
self.mapnik.width = width + 2 * self.buffer
self.mapnik.height = height + 2 * self.buffer
self.mapnik.zoom_to_box(mapnik.Box2d(ul.x, ul.y, lr.x, lr.y))
# create grid as same size as map/image
grid = mapnik.Grid(width + 2 * self.buffer, height + 2 * self.buffer)
# render a layer to that grid array
mapnik.render_layer(self.mapnik, grid, layer=self.layer_index, fields=self.fields)
# extract a gridview excluding the buffer
grid_view = grid.view(self.buffer, self.buffer, width, height)
# then encode the grid array as utf, resample to 1/scale the size, and dump features
grid_utf = grid_view.encode('utf', resolution=self.scale, add_features=True)
if self.wrapper is None:
return SaveableResponse(json.dumps(grid_utf))
else:
return SaveableResponse(self.wrapper + '(' + json.dumps(grid_utf) + ')')
def test_render_with_palette():
m = mapnik.Map(600, 400)
mapnik.load_map(m, '../data/good_maps/agg_poly_gamma_map.xml')
m.zoom_all()
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
with open('../data/palettes/palette256.act', 'rb') as act:
palette = mapnik.Palette(act.read(), 'act')
# test saving directly to filesystem
im.save('/tmp/mapnik-palette-test.png', 'png', palette)
expected = './images/support/mapnik-palette-test.png'
if os.environ.get('UPDATE'):
im.save(expected, "png", palette)
# test saving to a string
with open('/tmp/mapnik-palette-test2.png', 'wb') as f:
f.write(im.tostring('png', palette))
# compare the two methods
eq_(mapnik.Image.open('/tmp/mapnik-palette-test.png').tostring('png32'),
mapnik.Image.open(
'/tmp/mapnik-palette-test2.png').tostring('png32'),
'%s not eq to %s' % ('/tmp/mapnik-palette-test.png',
'/tmp/mapnik-palette-test2.png'))
# compare to expected
eq_(mapnik.Image.open('/tmp/mapnik-palette-test.png').tostring('png32'),
mapnik.Image.open(expected).tostring('png32'),
'%s not eq to %s' % ('/tmp/mapnik-palette-test.png',
expected))
def test_datasource_template_is_working():
m = mapnik.Map(256,256)
try:
mapnik.load_map(m,'../data/good_maps/datasource.xml')
except RuntimeError as e:
if "Required parameter 'type'" in str(e):
raise RuntimeError(e)
def test_render_mvt_with_optional_arguments():
# A dubious test ported from node-mapnik.
# TODO: make these optional arguments to have actual effect.
mvt = mapnik.VectorTileMerc(28, 12, 5)
with open('data/tile3.mvt', 'rb') as f:
buf = f.read();
eq_(isinstance(buf, bytes), True)
mapnik.merge_compressed_buffer(mvt, buf)
eq_(len(mvt.get_buffer()), 987)
eq_(mvt.is_painted, True)
eq_(mvt.is_empty, False)
m = mapnik.Map(256, 256)
m.maximum_extent = mapnik.Box2d(-20037508.34, -20037508.34, 20037508.34, 20037508.34)
mapnik.load_map(m, 'styles/mvt_render_test.xml')
im = mapnik.Image(m.width, m.height)
mapnik.render_mvt_merc(mvt, m, im,
scale_factor=1.2, scale_denom=1.5,
variables={ 'pizza': 'pie' })
expected = 'images/mvt/tile3.expected.png'
actual = 'images/mvt/tile3-2.actual.png'
im.save(actual, 'png32')
eq_(compare_file_size(actual, expected, 100), True)
def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
"""
"""
if self.mapnik is None:
self.mapnik = mapnik.Map(0, 0)
if exists(self.mapfile):
mapnik.load_map(self.mapnik, str(self.mapfile))
else:
handle, filename = mkstemp()
os.write(handle, urlopen(self.mapfile).read())
os.close(handle)
mapnik.load_map(self.mapnik, filename)
os.unlink(filename)
self.mapnik.width = width
self.mapnik.height = height
self.mapnik.zoom_to_box(mapnik.Envelope(xmin, ymin, xmax, ymax))
img = mapnik.Image(width, height)
mapnik.render(self.mapnik, img)
img = Image.fromstring('RGBA', (width, height), img.tostring())
return img
def renderPage(ll,file):
z = 2
#imgx = 987 * z
#imgy = 801 * z
imgx = int(987 * z )
imgy = int(987 * z *0.77 )
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")
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)
view = im.view(0,0,imgx,imgy) # x,y,width,height
map_uri=file + '.png'
view.save(map_uri,'png')
file=open(file+'.svg' ,'w')
surface=cairo.SVGSurface(file.name,imgx,imgy)
mapnik.render(m,surface)
#c = cairo.Context(surface)
#c.move_to(50,50)
#c.show_text('testing')
surface.finish();
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 test_render_mvt_raster_with_large_overzoom():
mvt = mapnik.VectorTileMerc(2788, 6533, 14);
with open('images/mvt/14_2788_6533.webp', 'rb') as f:
mapnik.add_image_layer(mvt, '_image', f.read())
# Look into the tile if there is the image
vti = mapnik.VectorTileInfo()
vti.parse_from_string(mvt.get_buffer())
eq_(vti.layers_size(), 1);
layer = vti.layers(0)
eq_(layer.features_size(), 1)
feature = layer.features(0)
raster = feature.raster()
eq_(len(raster), 98618)
img = mapnik.Image.frombuffer(raster)
eq_(img.width(), 512)
eq_(img.height(), 512)
m = mapnik.Map(256, 256)
mapnik.load_map(m, 'styles/large_overzoom.xml')
im = mapnik.Image(m.width, m.height)
mapnik.render_mvt_merc(mvt, m, im,
x=2855279, y=6690105, z=24,
scale_factor=1, buffer_size=256)
expected = 'images/mvt/large_overzoom.expected.png'
actual = 'images/mvt/large_overzoom.actual.png'
im.save(actual, 'png32')
eq_(compare_file_size(actual, expected, 100), True)
def test_arbitrary_parameters_attached_to_map():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/extra_arbitary_map_parameters.xml')
eq_(len(m.parameters),5)
eq_(m.parameters['key'],'value2')
eq_(m.parameters['key3'],'value3')
eq_(m.parameters['unicode'],u'iván')
eq_(m.parameters['integer'],10)
eq_(m.parameters['decimal'],.999)
m2 = mapnik.Map(256,256)
for k,v in m.parameters:
m2.parameters.append(mapnik.Parameter(k,v))
eq_(len(m2.parameters),5)
eq_(m2.parameters['key'],'value2')
eq_(m2.parameters['key3'],'value3')
eq_(m2.parameters['unicode'],u'iván')
eq_(m2.parameters['integer'],10)
eq_(m2.parameters['decimal'],.999)
map_string = mapnik.save_map_to_string(m)
m3 = mapnik.Map(256,256)
mapnik.load_map_from_string(m3,map_string)
eq_(len(m3.parameters),5)
eq_(m3.parameters['key'],'value2')
eq_(m3.parameters['key3'],'value3')
eq_(m3.parameters['unicode'],u'iván')
eq_(m3.parameters['integer'],10)
eq_(m3.parameters['decimal'],.999)
def main(args=None):
args = parser().parse_args(args)
m = mapnik.Map(args.size[0],args.size[0])
mapnik.load_map(m,args.map)
m.srs = merc.params()
# ensure the target map projection is mercator
if hasattr(mapnik,'Box2d'):
bbox = mapnik.Box2d(*args.bbox)
else:
bbox = mapnik.Envelope(*args.bbox)
# Our bounds above are in long/lat, but our map
# is in spherical mercator, so we need to transform
# the bounding box to mercator to properly position
# the Map when we call `zoom_to_box()`
transform = mapnik.ProjTransform(longlat,merc)
merc_bbox = transform.forward(bbox)
# Mapnik internally will fix the aspect ratio of the bounding box
# to match the aspect ratio of the target image width and height
# This behavior is controlled by setting the `m.aspect_fix_mode`
# and defaults to GROW_BBOX, but you can also change it to alter
# the target image size by setting aspect_fix_mode to GROW_CANVAS
#m.aspect_fix_mode = mapnik.GROW_CANVAS
# Note: aspect_fix_mode is only available in Mapnik >= 0.6.0
m.zoom_to_box(merc_bbox)
# render the map to an image
im = mapnik.Image(args.size[0], args.size[1])
mapnik.render(m, im)
im.save(args.output,'png')
def test_arbitrary_parameters_attached_to_map():
m = mapnik.Map(256, 256)
mapnik.load_map(m, "../data/good_maps/extra_arbitary_map_parameters.xml")
eq_(len(m.parameters), 5)
eq_(m.parameters["key"], "value2")
eq_(m.parameters["key3"], "value3")
eq_(m.parameters["unicode"], u"iván")
eq_(m.parameters["integer"], 10)
eq_(m.parameters["decimal"], 0.999)
m2 = mapnik.Map(256, 256)
for k, v in m.parameters:
m2.parameters.append(mapnik.Parameter(k, v))
eq_(len(m2.parameters), 5)
eq_(m2.parameters["key"], "value2")
eq_(m2.parameters["key3"], "value3")
eq_(m2.parameters["unicode"], u"iván")
eq_(m2.parameters["integer"], 10)
eq_(m2.parameters["decimal"], 0.999)
map_string = mapnik.save_map_to_string(m)
m3 = mapnik.Map(256, 256)
mapnik.load_map_from_string(m3, map_string)
eq_(len(m3.parameters), 5)
eq_(m3.parameters["key"], "value2")
eq_(m3.parameters["key3"], "value3")
eq_(m3.parameters["unicode"], u"iván")
eq_(m3.parameters["integer"], 10)
eq_(m3.parameters["decimal"], 0.999)
def render(data_dir, filename, config, scale_factor, reporting):
m = mapnik.Map(*config['sizes'][0])
try:
mapnik.load_map(m, os.path.join(data_dir, "styles", filename), True)
if not (m.parameters['status'] if (
'status' in m.parameters) else config['status']):
return
except Exception as e:
if 'Could not create datasource' in str(e) \
or 'Bad connection' in str(e) \
or 'Postgis Plugin: could not connect to server' in str(e):
return m
reporting.other_error(filename, repr(e))
return m
sizes = config['sizes']
if 'sizes' in m.parameters:
sizes = [[int(i) for i in size.split(',')]
for size in m.parameters['sizes'].split(';')]
ignored_renderers = config['ignored_renderers']
if 'ignored_renderers' in m.parameters:
ignored_renderers = m.parameters['ignored_renderers'].split(',')
for size in sizes:
m.width, m.height = size
if 'bbox' in m.parameters:
bbox = mapnik.Box2d.from_string(str(m.parameters['bbox']))
m.zoom_to_box(bbox)
else:
m.zoom_all()
name = filename[0:-4]
postfix = "%s-%d-%d-%s" % (name, m.width, m.height, scale_factor)
for renderer in renderers:
if renderer['name'] in ignored_renderers:
continue
if config.get(renderer['name'], True):
expected = os.path.join(data_dir, renderer['dir'], '%s-%s-reference.%s' %
(postfix, renderer['name'], renderer['filetype']))
actual = os.path.join(visual_output_dir, '%s-%s.%s' %
(postfix, renderer['name'], renderer['filetype']))
if not reporting.quiet:
print("\"%s\" with %s..." % (postfix, renderer['name']))
try:
renderer['render'](m, actual, scale_factor)
if not os.path.exists(expected):
reporting.not_found(actual, expected)
else:
diff = renderer['compare'](actual, expected)
if diff > renderer['threshold']:
reporting.result_fail(actual, expected, diff)
else:
reporting.result_pass(actual, expected, diff)
except Exception as e:
reporting.other_error(expected, repr(e))
return m
def test_hit_grid():
def rle_encode(l):
""" encode a list of strings with run-length compression """
return ["%d:%s" % (len(list(group)), name) for name, group in groupby(l)]
m = mapnik.Map(256,256);
try:
mapnik.load_map(m,'../data/good_maps/agg_poly_gamma_map.xml');
m.zoom_all()
join_field = 'NAME'
fg = [] # feature grid
for y in range(0, 256, 4):
for x in range(0, 256, 4):
featureset = m.query_map_point(0,x,y)
added = False
for feature in featureset.features:
fg.append(feature[join_field])
added = True
if not added:
fg.append('')
hit_list = '|'.join(rle_encode(fg))
eq_(hit_list[:16],'730:|2:Greenland')
eq_(hit_list[-12:],'1:Chile|812:')
except RuntimeError, e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(str(e))
def test_map_query_throw6():
m = mapnik.Map(256, 256)
mapnik.load_map(m, "../data/good_maps/merc2wgs84_reprojection.xml")
wgs84_bounds = mapnik.Box2d(-180, -90, 180, 90)
m.maximum_extent = wgs84_bounds
m.zoom_all()
m.query_point(0, -180, -90)
def render_tile(mapfile, tile_uri, x, y, z): m = mapnik.Map(256, 256) # 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(z+1) # 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 = tileproj.fromPixelToLL(p0, z); l1 = tileproj.fromPixelToLL(p1, z); # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = prj.forward(mapnik.Coord(l0[0],l0[1])) c1 = prj.forward(mapnik.Coord(l1[0],l1[1])) # Bounding box for the tile bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y) render_size = 256 m.resize(render_size, render_size) m.zoom_to_box(bbox) m.buffer_size = 128 # Render image with default Agg renderer im = mapnik.Image(render_size, render_size) mapnik.render(m, im) im.save(tile_uri, 'png256')
def loop(self):
self.m = mapnik.Map(256, 256)
# Load style XML
mapnik.load_map(self.m, self.mapfile, True)
# Obtain <Map> projection
self.prj = mapnik.Projection(self.m.srs)
# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
self.tileproj = GoogleProjection(self.maxZoom+1)
while True:
#Fetch a tile from the queue and render it
r = self.q.get()
if (r == None):
self.q.task_done()
break
else:
(name, tile_uri, x, y, z) = r
exists= ""
if os.path.isfile(tile_uri):
exists= "exists"
else:
self.render_tile(tile_uri, x, y, z)
bytes=os.stat(tile_uri)[6]
empty= ''
if bytes == 103:
empty = " Empty Tile "
self.printLock.acquire()
print(name, ":", z, x, y, exists, empty)
self.printLock.release()
self.q.task_done()
def __init__(self, style, empty=None, maxzoom=18):
models.Manager.__init__(self)
self.emptytile = empty
self.map = mapnik.Map(256, 256)
mapnik.load_map(self.map, style)
self.mproj = mapnik.Projection(self.map.srs)
self.gproj = GoogleProjection(maxzoom)
def load_map(self):
self.mapnik_map = mapnik.Map(self.width, self.height)
mapnik.load_map(self.mapnik_map, self.mapfile)
if self.srs:
proj_init = str('+init=%s' % self.srs).lower()
self.projection = mapnik.Projection(proj_init)
self.mapnik_map.srs = self.projection.params()
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 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 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 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 test_map_query_works1():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/wgs842merc_reprojection.xml')
merc_bounds = mapnik.Box2d(-20037508.34,-20037508.34,20037508.34,20037508.34)
m.maximum_extent = merc_bounds
m.zoom_all()
fs = m.query_point(0,-11012435.5376, 4599674.6134) # somewhere in kansas
feat = fs.next()
eq_(feat.attributes['NAME_FORMA'],u'United States of America')
def __init__(self, tile_dir, mapfile, maxZoom):
self.tile_dir = tile_dir
self.m = mapnik.Map(256, 256)
# Load style XML
mapnik.load_map(self.m, mapfile, True)
# Obtain <Map> projection
self.prj = mapnik.Projection(self.m.srs)
# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
self.tileproj = GoogleProjection(maxZoom + 1)
def renderTile(self, tile):
import mapnik, StringIO
import PIL.Image
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'):
data = im.tostring()
elif hasattr(mapnik, 'rawdata'):
data = mapnik.rawdata(im)
else:
raise Exception(
"Something is wrong: your version of Mapnik can't create a string from an image."
)
im = PIL.Image.fromstring('RGBA', tile.size(), data)
buffer = StringIO.StringIO()
im.save(buffer, self.extension)
buffer.seek(0)
tile.data = buffer.read()
return tile.data
def run(self):
map = mapnik.Map(self.sizex, self.sizey)
mapnik.load_map(map, self.mapname + ".xml")
result = renderLayerLL(self.mapname, self.envLL, self.sizex,
self.sizey, map)
console.debugMessage(' Rendered layer: ' + self.mapname)
self.imagesLock.acquire()
self.images[self.mapname] = result
self.imagesLock.release()
def test_map_query_in_pixels_works1():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/wgs842merc_reprojection.xml')
merc_bounds = mapnik.Box2d(-20037508.34,-20037508.34,20037508.34,20037508.34)
m.maximum_extent = merc_bounds
m.zoom_all()
fs = m.query_map_point(0,55,100) # somewhere in middle of us
feat = fs.next()
eq_(feat.attributes['NAME_FORMA'],u'United States of America')
def tms(z, x, y, service):
# (4370311.220000, 4911352.860000) - (4403732.650000, 4958349.910000)
# Extent: (4370177.610000, 4908530.650000) - (4411390.670000, 4958581.500000)
bbox = dict(minx=4370177, miny=4908530, maxx=4411390, maxy=4958581)
step = max(bbox['maxx'] - bbox['minx'], bbox['maxy'] - bbox['miny']) / 2**z
extents = dict()
extents['tms'] = (bbox['minx'] + x * step, bbox['miny'] + y * step,
bbox['minx'] + (x + 1) * step,
bbox['miny'] + (y + 1) * step)
extents['xyz'] = (bbox['minx'] + x * step, bbox['maxy'] - (y + 1) * step,
bbox['minx'] + (x + 1) * step, bbox['maxy'] - y * step)
tile = dict(width=256, height=256)
map = mapnik.Map(tile['width'], tile['height'])
map.background = mapnik.Color('steelblue')
mapnik.load_map(map, 'tile_server/style/styles.xml')
layer = mapnik.Layer('point')
ds = mapnik.PostGIS(host='127.0.0.1',
dbname='isogd_sevastopol',
user='******',
password='******',
table='tableapi.table_test_2_points_2')
layer.datasource = ds
pdb.set_trace()
style = mapnik.Style()
rule = mapnik.Rule()
point_symbolizer = mapnik.PointSymbolizer()
point_symbolizer.file = "/style/point_style.png"
# pdb.set_trace()
rule.symbols.append(point_symbolizer)
style.rules.append(rule)
map.append_style('My Style', style)
map.zoom_all()
mapnik.render_to_file(map, 'altay.png', 'png')
box = mapnik.Box2d(*extents.get(service))
# map.zoom_all()
map.zoom_to_box(box)
mapnik.render_to_file(map, 'world.png', 'png')
im = mapnik.Image(map.width, map.height)
mapnik.render(map, im)
output = im.tostring('png')
# box = mapnik.Box2d(*extents.get(service))
# map.zoom_to_box(box)
# mapnik.render_to_file(map, 'world.png', 'png')
# im = mapnik.Image(map.width, map.height)
# mapnik.render(map, im)
# output = im.tostring('png')
# # Передаём ответ клиенту
return output
def application(env, start_response):
global stylename
global map_template
status = '200 OK'
pathinfo=env['PATH_INFO']
# read configuration file
config = ConfigParser.ConfigParser()
cfgfile="tileserver.conf"
config.read(cfgfile)
stylename = config_get(config,"global","stylename","osm.xml")
styledir = config_get(config,"global","styledir","../mapnik-stylesheets")
map_template = config_get(config,"global","map_template","map_template_leaflet.html")
# show static content when URL starts with '/static/'
m = re.match(r"^/static/(.+)$", pathinfo)
if m:
return showStaticContent(start_response, m.group(1))
# mod-wsgi gives control to our script only for /name and /name/...
# thus any length <2 should show the overview page
if len(pathinfo) < 2:
return genSlippyMap(start_response)
m = re.match(r"^/tiles/([0-9]+)/+([0-9]+)/+([0-9]+).png$", pathinfo)
if m is None:
msg="Invalid URL: %s<br />should be /tiles/<z>/<x>/<y>.png" % pathinfo
return InvalidURL(start_response,msg,'404 Invalid URL')
z=int(m.group(1))
x=int(m.group(2))
y=int(m.group(3))
# check for mapnik style file in requested sandbox
import os.path
mapfile=os.path.join(styledir,stylename)
if not os.path.exists(mapfile):
msg="ERROR: stylename >%s< does not exist!!!" % stylename
return InvalidURL(start_response,msg,'404 Invalid sandbox')
# we have a valid Tile-URL request so just render the tile now
m = mapnik.Map(256, 256)
mapnik.load_map(m, mapfile)
bba=TileToBBox(x,y,z)
bbox=mapnik.Box2d(bba[0],bba[1],bba[2],bba[3])
m.zoom_to_box(bbox)
im = mapnik.Image(256, 256)
mapnik.render(m, im)
output = im.tostring('png')
response_headers = [('Content-type', 'image/png'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
def render_map(_map, mimetype='application/pdf'):
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')
transform = mapnik.ProjTransform(longlat, merc)
bbox = mapnik.Box2d(*_map.bbox)
merc_bbox = transform.forward(bbox)
mapnik_map = mapnik.Map(int(merc_bbox.width()), int(merc_bbox.height()))
mapnik_map.zoom_to_box(merc_bbox)
mapnik_map.buffer_size = 5
# add osm data
mapnik.load_map(mapnik_map, current_app.config['MAPNIK_OSM_XML'])
# add grid
data = _map.grid
path = os.path.join(SRC_PATH, "maps-xml/grid.xml")
xml_str = get_xml(path).format(json.dumps(data)).encode()
mapnik.load_map_from_string(mapnik_map, xml_str)
# add all features
features = FeatureCollection([f.to_dict() for f in _map.features])
path = os.path.join(SRC_PATH, "maps-xml/features.xml")
xml_str = get_xml(path).format(json.dumps(features)).encode()
mapnik.load_map_from_string(mapnik_map, xml_str)
# add legend
add_legend(mapnik_map, _map.legend)
# export as in-memory file
f = io.BytesIO()
if mimetype == 'image/svg+xml':
surface = cairo.SVGSurface(f, mapnik_map.width, mapnik_map.height)
elif mimetype == 'image/png':
ratio = float(mapnik_map.height) / mapnik_map.width
mapnik.height = 800
mapnik.width = int(600 * ratio)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, mapnik_map.width,
mapnik_map.height)
else:
surface = cairo.PDFSurface(f, mapnik_map.width, mapnik_map.height)
mapnik.render(mapnik_map, surface)
if mimetype == 'image/png':
surface.write_to_png(f)
surface.finish()
f.seek(0)
return f
def __init__(self,
stylesheet,
bounding_box,
_width,
_height,
dpi=72.0,
extend_bbox_to_ratio=True):
"""Initialize the map canvas for rendering.
Args:
stylesheet (Stylesheet): map stylesheet.
bounding_box (coords.BoundingBox): geographic bounding box.
graphical_ratio (float): ratio of the map area (width/height).
dpi (float): map resolution (default: 72dpi)
extend_bbox_to_ratio (boolean): allow MapCanvas to extend
the bounding box to make it match the ratio of the
provided rendering area. Needed by SinglePageRenderer.
"""
self._proj = mapnik.Projection(_MAPNIK_PROJECTION)
self._dpi = dpi
# This is where the magic of the map canvas happens. Given an original
# bounding box and a graphical ratio for the output, the bounding box
# is adjusted (extended) to fill the destination zone. See
# _fix_bbox_ratio for more details on how this is done.
orig_envelope = self._project_envelope(bounding_box)
graphical_ratio = _width / _height
if extend_bbox_to_ratio:
off_x, off_y, width, height = self._fix_bbox_ratio(
orig_envelope.minx, orig_envelope.miny, orig_envelope.width(),
orig_envelope.height(), graphical_ratio)
envelope = mapnik.Box2d(off_x, off_y, off_x + width,
off_y + height)
self._geo_bbox = self._inverse_envelope(envelope)
LOG.debug('Corrected bounding box from %s to %s, ratio: %.2f.' %
(bounding_box, self._geo_bbox, graphical_ratio))
else:
envelope = orig_envelope
self._geo_bbox = bounding_box
g_width = int(convert_pt_to_dots(_width, dpi))
g_height = int(convert_pt_to_dots(_height, dpi))
# Create the Mapnik map with the corrected width and height and zoom to
# the corrected bounding box ('envelope' in the Mapnik jargon)
self._map = mapnik.Map(g_width, g_height, _MAPNIK_PROJECTION)
mapnik.load_map(self._map, stylesheet.path)
self._map.zoom_to_box(envelope)
# Added shapes to render
self._shapes = []
LOG.debug('MapCanvas rendering map on %dx%dpx.' % (g_width, g_height))
def render(self, input_file, extent, lyr_style):
proj4lyr = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
county_file = '../datas/county.shp'
# river_file = '../datas/river.shp'
# capital_file ='Capital3.json'
filename = os.path.split(input_file)[1]
areaCode = os.path.splitext(filename)[0]
output_file = input_file.split('.')[0] + '.png'
print areaCode
# ----------create map---------------------
m = mapnik.Map(extent.xsize, extent.ysize)
mapnik.load_map(m, 'cg_config.xml')
# ----------create layer 1-----------------
layer = mapnik.Layer('dataraster', proj4lyr)
# ----------create layer 1 datasource------
layer.datasource = mapnik.Gdal(file=input_file, band=1, nodata=-999)
layer.styles.append(lyr_style)
# ----------append layer 1 to map----------
m.layers.append(layer)
# ----------create layer 2-----------------
layer2 = mapnik.Layer('county', proj4lyr)
# Create new styles and add the rules.
s_county = m.find_style('county')
r_county = s_county.rules[0]
r_county.filter = mapnik.Filter('[CITY]=' + areaCode)
m.append_style(areaCode, s_county)
# ----------create layer 2 datasource------
layer2.datasource = mapnik.Shapefile(file=county_file)
layer2.styles.append(areaCode)
# ----------append layer 2 to map----------
m.layers.append(layer2)
# ----------create layer 3-----------------
layer3 = mapnik.Layer('capital', proj4lyr)
# Create new styles and add the rules.
s_capital = m.find_style('capital')
r_capital = s_capital.rules[0]
r_capital.filter = mapnik.Filter('[CITY]=' + areaCode)
m.append_style('symbol', s_capital)
# ----------create layer 3 datasource------
layer3.datasource = mapnik.Shapefile(file=county_file)
layer3.styles.append('symbol')
# ----------append layer 3 to map----------
m.layers.append(layer3)
ll = mapnik.Coord(extent.xmax, extent.ymax)
tr = mapnik.Coord(extent.xmin, extent.ymin)
map_bbox = mapnik.Box2d(tr, ll) # mapnik.Envelope(tr, ll)
m.zoom_to_box(map_bbox)
print m.envelope(), m.scale()
mapnik.render_to_file(m, output_file, 'png')
return 'true'
def compare_map(xml):
m = mapnik.Map(256, 256)
absolute_base = os.path.abspath(os.path.dirname(xml))
try:
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
def test_buffer_size_from_style_overriden_by_parameter():
m = mapnik.Map(256, 256)
mapnik.load_map(m, 'styles/map_buffer_size.xml')
mvt_buffer = mapnik.create_mvt_merc(m, 2048, 2047, 12, buffer_size=0)
tile = mapnik.VectorTileInfo()
tile.parse_from_string(mvt_buffer)
eq_(tile.layers_size(), 1)
eq_(tile.layers(0).features_size(), 1)
def __init__(self, request):
self.map = mapnik.Map(1, 1)
mapfile = request.GET['LAYERS'].split(',')[0] + '.xml'
mapfile_path = os.path.join(settings.MAPFILES, mapfile)
mapnik.load_map(self.map, str(mapfile_path))
try:
p = mapnik.Projection('+init=%s' % str(request.GET['SRS']))
except:
p = mapnik.Projection(MERC_PROJ4)
self.map.srs = p.params()
def test_arbitrary_parameters_attached_to_map():
m = mapnik.Map(256, 256)
mapnik.load_map(m, '../data/good_maps/extra_arbitary_map_parameters.xml')
eq_(len(m.parameters), 6)
eq_(m.parameters['key'], 'value2')
eq_(m.parameters['key3'], 'value3')
eq_(m.parameters['unicode'], u'iván')
eq_(m.parameters['integer'], 10)
eq_(m.parameters['decimal'], .999)
eq_(m.parameters['number-as-string'], u'.9998')
def render(filename, config, scale_factor, reporting):
m = mapnik.Map(*config['sizes'][0])
try:
mapnik.load_map(m, os.path.join(dirname, "styles", filename), True)
if not (m.parameters['status'] if
('status' in m.parameters) else config['status']):
return
except Exception as e:
if 'Could not create datasource' in str(e) \
or 'Bad connection' in str(e):
return m
reporting.other_error(filename, repr(e))
return m
sizes = config['sizes']
if 'sizes' in m.parameters:
sizes = [[int(i) for i in size.split(',')]
for size in m.parameters['sizes'].split(';')]
for size in sizes:
m.width, m.height = size
if 'bbox' in m.parameters:
bbox = mapnik.Box2d.from_string(str(m.parameters['bbox']))
m.zoom_to_box(bbox)
else:
m.zoom_all()
name = filename[0:-4]
postfix = "%s-%d-%d-%s" % (name, m.width, m.height, scale_factor)
for renderer in renderers:
if config.get(renderer['name'], True):
expected = os.path.join(
dirname, renderer['dir'], '%s-%s-reference.%s' %
(postfix, renderer['name'], renderer['filetype']))
actual = os.path.join(
visual_output_dir, '%s-%s.%s' %
(postfix, renderer['name'], renderer['filetype']))
if not quiet:
print("\"%s\" with %s..." % (postfix, renderer['name']))
try:
renderer['render'](m, actual, scale_factor)
if not os.path.exists(expected):
reporting.not_found(actual, expected)
else:
diff = renderer['compare'](actual, expected)
if diff > renderer['threshold']:
reporting.result_fail(actual, expected, diff)
else:
reporting.result_pass(actual, expected, diff)
except Exception as e:
reporting.other_error(expected, repr(e))
return m
def test_layer_sublayers():
m = mapnik.Map(512, 512)
strict = True
filename = "../data/good_maps/nested-layers-1.xml"
mapnik.load_map(m, filename, strict)
eq_(len(m.layers), 1)
eq_(len(m.layers[0].layers), 1)
sublayer = m.layers[0].layers[0]
eq_(sublayer.name, "text")
def test_tif_rendering_nodata():
m = mapnik.Map(512,512)
mapnik.load_map(m,'../data/good_maps/tiff_colortable.xml')
m.zoom_all()
im = mapnik.Image(512,512)
mapnik.render(m,im)
actual = '/tmp/tif_colortable.png'
expected = 'images/support/tif_colortable.png'
im.save(actual)
expected_im = mapnik.Image.open(expected)
eq_(im.tostring(),expected_im.tostring(), 'failed comparing actual (%s) and expected(%s)' % (actual,'tests/python_tests/'+ expected))
def test_edge_scaling_with_nodata():
m = mapnik.Map(600,400)
mapnik.load_map(m,'../data/good_maps/raster-nodata-edge.xml')
m.zoom_all()
actual = '/tmp/mapnik-raster-nodata-edge.png'
expected = 'images/support/raster-nodata-edge.png'
im = mapnik.Image(m.width,m.height)
mapnik.render(m,im)
im.save(actual)
expected_im = mapnik.Image.open(expected)
eq_(im.tostring(),expected_im.tostring(), 'failed comparing actual (%s) and expected(%s)' % (actual,'tests/python_tests/'+ expected))
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_marker_ellipse_render1():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/marker_ellipse_transform.xml')
m.zoom_all()
im = mapnik.Image(m.width,m.height)
mapnik.render(m,im)
actual = '/tmp/mapnik-marker-ellipse-render1.png'
expected = 'images/support/mapnik-marker-ellipse-render1.png'
im.save(actual)
expected_im = mapnik.Image.open(expected)
eq_(im.tostring(),expected_im.tostring(), 'failed comparing actual (%s) and expected (%s)' % (actual,'tests/python_tests/'+ expected))
def test_style_level_opacity():
m = mapnik.Map(512,512)
mapnik.load_map(m,'../data/good_maps/style_level_opacity_and_blur.xml')
m.zoom_all()
im = mapnik.Image(512,512)
mapnik.render(m,im)
actual = '/tmp/mapnik-style-level-opacity.png'
expected = 'images/support/mapnik-style-level-opacity.png'
im.save(actual,'png32')
expected_im = mapnik.Image.open(expected)
eq_(im.tostring('png32'),expected_im.tostring('png32'), 'failed comparing actual (%s) and expected (%s)' % (actual,'tests/python_tests/'+ expected))
def _add_layer(self, filename, datasources):
if not isinstance(datasources, list):
datasources = [datasources]
idx = len(self._map.layers)
current_dir = pathlib.Path(__file__).parent
mapnik.load_map(self._map, str(current_dir / '..' / filename))
for ds in datasources:
data = mapnik.Datasource(type='geojson', inline=json.dumps(ds))
self._map.layers[idx].datasource = data
idx += 1
def test_map_query_in_pixels_works2():
m = mapnik.Map(256,256)
mapnik.load_map(m,'../data/good_maps/merc2wgs84_reprojection.xml')
wgs84_bounds = mapnik.Box2d(-179.999999975,-85.0511287776,179.999999975,85.0511287776)
m.maximum_extent = wgs84_bounds
# caution - will go square due to evil aspect_fix_mode backhandedness
m.zoom_all()
# validate that aspect_fix_mode modified the bbox reasonably
eq_(str(m.envelope()),str(mapnik.Box2d(-179.999999975,-167.951396161,179.999999975,192.048603789)))
fs = m.query_map_point(0,55,100) # somewhere in Canada
feat = fs.next()
eq_(feat.attributes['NAME'],u'Canada')
