def test_mutability_of_styles_from_iterator():
"""
Should be able to mutate style by a reference
returned from the iterator
"""
p = mapnik.PointSymbolizer()
p.allow_overlap = True
p.opacity = 0.5
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(256, 256)
m.append_style('s', s)
for style_name, style in m.styles:
eq_(style_name, 's')
eq_(len(style.rules), 1)
style.rules.append(mapnik.Rule())
eq_(len(style.rules), 2)
for style_name, style in m.styles:
eq_(style_name, 's')
eq_(len(style.rules), 2)
def test_mutability_of_styles_by_find_style():
"""
Should be able to mutate style by a reference
returned from find_style()
"""
p = mapnik.PointSymbolizer()
p.allow_overlap = True
p.opacity = 0.5
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(256, 256)
m.append_style('s', s)
s2 = m.find_style('s')
eq_(len(s2.rules), 1)
s3 = m.find_style('s')
s3.rules.append(mapnik.Rule())
# Both referefences should point to the same object
eq_(len(s3.rules), 2)
eq_(len(s2.rules), 2)
def __add_manholes(self, layers, styles):
"Add manhole layer and styles."
# Select the manholes that are part of this sewerage.
manholes = Manhole.objects.filter(sewerage__pk=self.id)
# Define a style.
style = mapnik.Style()
# Style the `normal` manholes.
rule = mapnik.Rule()
rule.filter = mapnik.Filter("[sink] != 1")
symbol = mapnik.PointSymbolizer()
symbol.allow_overlap = True
rule.symbols.append(symbol)
style.rules.append(rule)
# Style the sink.
rule = mapnik.Rule()
rule.filter = mapnik.Filter("[sink] = 1")
symbol = mapnik.PointSymbolizer(
str(finders.find("lizard_riool/sink.png")), "png", 8, 8
)
symbol.allow_overlap = True
rule.symbols.append(symbol)
style.rules.append(rule)
# Add labels.
rule = mapnik.Rule()
rule.max_scale = 1700
symbol = mapnik.TextSymbolizer(
'code', 'DejaVu Sans Book', 10, mapnik.Color('black')
)
symbol.allow_overlap = True
symbol.label_placement = mapnik.label_placement.POINT_PLACEMENT
symbol.vertical_alignment = mapnik.vertical_alignment.TOP
symbol.displacement(0, -5) # slightly above
rule.symbols.append(symbol)
style.rules.append(rule)
# Setup datasource.
params = default_database_params()
params['table'] = "({}) data".format(manholes.query)
datasource = mapnik.PostGIS(**params)
# Define layer.
layer = mapnik.Layer('manholeLayer')
layer.datasource = datasource
layer.maxzoom = 35000
layer.styles.append('manholeStyle')
layers.append(layer)
styles['manholeStyle'] = style
def __init__(self):
BaseWMSFactory.__init__(self)
layer = mapnik.Layer('TOP', modis_srs)
layer.datasource = mapnik.Gdal(file=str(data),band=1)
layer.title = "Modis VI Layer"
layer.queryable = True
layer.wms_srs = None
style = mapnik.Style()
rule = mapnik.Rule()
sym = mapnik.RasterSymbolizer()
sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE, mapnik.Color("transparent"))
scale = getModisScale(product)
for color in scale:
sym.colorizer.add_stop(color['stop'], mapnik.Color(*color['color']))
rule.symbols.append(sym)
style.rules.append(rule)
self.register_style('modis_style', style)
self.register_layer(layer, "modis_style",("modis_style",))
layer = mapnik.Layer('ocean_mask')
layer.datasource = mapnik.Shapefile(file=str("/data/health/data1/web/data/shapes/50m_ocean.shp"))
layer.queryable = True
layer.wms_srs = None
style = mapnik.Style()
rule = mapnik.Rule()
poly_sym = mapnik.PolygonSymbolizer(mapnik.Color('#50649B'))
rule.symbols.append(poly_sym)
style.rules.append(rule)
self.register_style('mask_style', style)
self.register_layer(layer, "mask_style",("mask_style",))
def layer(self, layer_ids=None, request=None):
"""Return mapnik layers and styles."""
layers = []
styles = {}
style = mapnik.Style()
styles["riverlineadapterstyle"] = style
if self.riverline_result.is_reference:
range_method = self._reference_ranges
level_field = 'level'
else:
range_method = self._ranges
level_field = 'relative_level'
for from_, to_, color in range_method():
rule = mapnik.Rule()
if from_ is None:
rule.filter = mapnik.Filter("[value] < %s" % to_)
elif to_ is None:
rule.filter = mapnik.Filter("[value] > %s" % from_)
else:
rule.filter = mapnik.Filter("[value] > %s and [value] < %s" %
(from_, to_))
symbol = mapnik.LineSymbolizer(
mapnik.Color(color[0], color[1], color[2]), 3)
rule.symbols.append(symbol)
style.rules.append(rule)
# Catch all rule for unknown states:
rule = mapnik.Rule()
rule.set_else(True)
symbol = mapnik.LineSymbolizer(mapnik.Color(100, 100, 100), 3)
rule.symbols.append(symbol)
style.rules.append(rule)
query = """(
select riverline.the_geom, row.%s as value
from lizard_rijnmond_riverline riverline,
lizard_rijnmond_riverlineresultdata row
where riverline.verbose_code = row.location
and row.riverline_result_id = %s
) as data""" % (level_field, self.riverline_result_id)
logger.info(query)
default_database = settings.DATABASES['default']
datasource = mapnik.PostGIS(
host=default_database['HOST'],
user=default_database['USER'],
password=default_database['PASSWORD'],
dbname=default_database['NAME'],
table=str(query),
)
layer = mapnik.Layer("Riverlines", coordinates.RD)
layer.datasource = datasource
layer.styles.append("riverlineadapterstyle")
layers.append(layer)
return layers, styles
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())
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())
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())
r.symbols.append(mapnik.LineSymbolizer())
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,'/tmp/mapnik-postgis-test-map1.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,'/tmp/mapnik-postgis-test-map2.png', 'png')
def singlePolyStyle(self,
clr,
outlineColor="#000000",
outlineThikness=0.1):
polyS = mapnik.Style()
r = mapnik.Rule()
s = mapnik.PolygonSymbolizer(mapnik.Color(clr))
r.symbols.append(s)
polyS.rules.append(r)
r = mapnik.Rule()
s = mapnik.LineSymbolizer(mapnik.Color(outlineColor), outlineThikness)
r.symbols.append(s)
polyS.rules.append(r)
return polyS
def index(request):
m = mapnik.Map(700, 700)
m.background = mapnik.Color("white")
polygons = mapnik.PolygonSymbolizer()
polygons.fill = mapnik.Color("orange")
rules = mapnik.Rule()
rules.symbols.append(polygons)
style = mapnik.Style()
style.rules.append(rules)
# Creating rules
highlight = mapnik.PolygonSymbolizer()
highlight.fill = mapnik.Color('red')
r = mapnik.Rule()
r.filter = mapnik.Expression("[productivi] <= 31")
r.symbols.append(highlight)
style.rules.append(r)
highlight.fill = mapnik.Color('green')
g = mapnik.Rule()
g.filter = mapnik.Expression("[productivi] >= 70")
g.symbols.append(highlight)
style.rules.append(g)
m.append_style('Polygons', style)
layer = mapnik.Layer('A')
layer.datasource = mapnik.PostGIS(host='127.0.0.1',user='******', \
password='******',dbname='geotest', \
table='map_map', srid='3857')
layer.styles.append('Polygons')
m.layers.append(layer)
rules.symbols.append(polygons)
style.rules.append(rules)
m.zoom_all()
mapnik.render_to_file(m, os.path.abspath('FileStorage/polygons.png'), 'png')
return render(request, 'base.html')
def test_that_coordinates_do_not_overflow_and_polygon_is_rendered_csv():
expected_color = mapnik.Color('white')
projection = '+init=epsg:4326'
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
feat = mapnik.Feature.from_geojson(json.dumps(geojson), context)
ds.add_feature(feat)
geojson_string = "geojson\n'%s'" % json.dumps(geojson['geometry'])
ds = mapnik.Datasource(**{'type': 'csv', 'inline': geojson_string})
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.PolygonSymbolizer()
sym.fill = expected_color
r.symbols.append(sym)
s.rules.append(r)
lyr = mapnik.Layer('Layer', projection)
lyr.datasource = ds
lyr.styles.append('style')
m = mapnik.Map(256, 256, projection)
m.background_color = mapnik.Color('green')
m.append_style('style', s)
m.layers.append(lyr)
# 17/20864/45265.png
m.zoom_to_box(
mapnik.Box2d(-13658379.710221574, 6197514.253362091,
-13657768.213995293, 6198125.749588372))
# works 15/5216/11316.png
# m.zoom_to_box(mapnik.Box2d(-13658379.710221574,6195679.764683247,-13655933.72531645,6198125.749588372))
im = mapnik.Image(256, 256)
mapnik.render(m, im)
eq_(im.get_pixel(128, 128), expected_color.packed())
def test_raster_warping():
lyrSrs = "+init=epsg:32630"
mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
lyr = mapnik.Layer('dataraster', lyrSrs)
if 'gdal' in mapnik.DatasourceCache.plugin_names():
lyr.datasource = mapnik.Gdal(
file='../data/raster/dataraster.tif',
band=1,
)
sym = mapnik.RasterSymbolizer()
sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
mapnik.Color(255, 255, 0))
rule = mapnik.Rule()
rule.symbols.append(sym)
style = mapnik.Style()
style.rules.append(rule)
_map = mapnik.Map(256, 256, mapSrs)
_map.append_style('foo', style)
lyr.styles.append('foo')
_map.layers.append(lyr)
map_proj = mapnik.Projection(mapSrs)
layer_proj = mapnik.Projection(lyrSrs)
prj_trans = mapnik.ProjTransform(map_proj, layer_proj)
_map.zoom_to_box(prj_trans.backward(lyr.envelope()))
im = mapnik.Image(_map.width, _map.height)
mapnik.render(_map, im)
imdata = im.tostring()
assert contains_word('\xff\xff\x00\xff', imdata)
def test_raster_warping_does_not_overclip_source():
lyrSrs = "+init=epsg:32630"
mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
lyr = mapnik.Layer('dataraster', lyrSrs)
if 'gdal' in mapnik.DatasourceCache.plugin_names():
lyr.datasource = mapnik.Gdal(
file='../data/raster/dataraster.tif',
band=1,
)
sym = mapnik.RasterSymbolizer()
sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
mapnik.Color(255, 255, 0))
rule = mapnik.Rule()
rule.symbols.append(sym)
style = mapnik.Style()
style.rules.append(rule)
_map = mapnik.Map(256, 256, mapSrs)
_map.background = mapnik.Color('white')
_map.append_style('foo', style)
lyr.styles.append('foo')
_map.layers.append(lyr)
_map.zoom_to_box(mapnik.Box2d(3, 42, 4, 43))
im = mapnik.Image(_map.width, _map.height)
mapnik.render(_map, im)
assert im.view(0, 200, 1, 1).tostring() == '\xff\xff\x00\xff'
def mapnik_lyr(mapobj, data=None, line_sym=None):
################################################################################
# m = mapnik.Map(600, 300, "+proj=latlong +datum=WGS84")
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(line_sym)
s.rules.append(r)
sname = str(int(time.time()))
print(sname)
time.sleep(1)
mapobj.append_style(sname, s)
# line_symbolizer = mapnik.LineSymbolizer()
# line_symbolizer.stroke = mapnik.Color('rgb(100%,50%,50%)')
# ################################################################################
# line_symbolizer.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
#
# line_symbolizer.stroke_width = 4.0
#
# s2 = mapnik.Style()
# r2 = mapnik.Rule()
# r2.symbols.append(line_symbolizer)
# s2.rules.append(r2)
# mapobj.append_style('My Style2', s2)
lyr = mapnik.Layer('world', "+proj=latlong +datum=WGS84")
# lyr.datasource = mapnik.Shapefile(file='/gdata/world_borders.shp')
lyr.datasource = mapnik.Shapefile(file=data)
lyr.styles.append(sname)
return lyr
def renderit(line_sym=None, poly_sym=None, point_sym=None, shpfile=None, fig_index=0):
################################################################################
m = mapnik.Map(600, 300, "+proj=latlong +datum=WGS84")
s = mapnik.Style()
r = mapnik.Rule()
# line_sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
# line_sym.stroke_linejoin = mapnik.stroke_linejoin.ROUND_JOIN
# line_sym.stroke_dasharray = [(3,4)]
# line_sym.stroke_linecap = mapnik.stroke_linecap.SQUARE_CAP
if poly_sym:
r.symbols.append(poly_sym)
if point_sym:
r.symbols.append(point_sym)
if line_sym:
r.symbols.append(line_sym)
s.rules.append(r)
m.append_style('My Style', s)
lyr = mapnik.Layer('world', "+proj=latlong +datum=WGS84")
# lyr.datasource = mapnik.Shapefile(file='/gdata/world_borders.shp')
if shpfile:
lyr.datasource = mapnik.Shapefile(file=shpfile)
else:
lyr.datasource = mapnik.Shapefile(file=os.path.join(BASE_PATH, 'fig_data_line.shp'))
lyr.styles.append('My Style')
m.layers.append(lyr)
# bbox = mapnik.Box2d(118, 36.6, 124.6, 40.7)
# m.zoom_to_box(bbox)
m.zoom_all()
return m
def init_map(zoom, seq):
m = mapnik.Map(256, 256, merc_srs)
m.background_color = mapnik.Color('white')
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.MarkersSymbolizer()
sym.fill = mapnik.Color('black')
sym.spacing = 0.0
sym.opacity = opacity(zoom)
sym.height = mapnik.Expression(str(pointWeight(zoom) / 2.0))
sym.width = mapnik.Expression(str(pointWeight(zoom) / 2.0))
# Ignore placement instructs Mapnik to avoid building the quadtree
# collision cache and helps performance if you know you want to
# allow for overlaps between features.
# - Dane
sym.allow_overlap = True
sym.ignore_placement = True
r.symbols.append(sym)
s.rules.append(r)
m.append_style('point_style', s)
TuplesDatasource.set_source(seq)
ds = mapnik.Python(factory='TuplesDatasource')
layer = mapnik.Layer('file', merc_srs)
layer.datasource = ds
layer.styles.append('point_style')
m.layers.append(layer)
return m
def _addStyleToMap(self, m, layerSrs, colorizer=None, band=-1, extent=None,
composite=None, nodata=None):
"""
Add a mapik raster symbolizer to a map.
:param m: mapnik map.
:param layerSrs: the layer projection
:param colorizer: a mapnik colorizer.
:param band: an integer band number. -1 for default.
:param extent: the extent to use for the mapnik layer.
:param composite: the composite operation to use. This is one of
mapnik.CompositeOp.xxx, typically lighten or multiply.
:param nodata: the value to use for missing data or None to use all
data.
"""
styleName = 'Raster Style'
if band != -1:
styleName += ' ' + str(band)
rule = mapnik.Rule()
sym = mapnik.RasterSymbolizer()
if colorizer is not None:
sym.colorizer = colorizer
rule.symbols.append(sym)
style = mapnik.Style()
style.rules.append(rule)
if composite is not None:
style.comp_op = composite
m.append_style(styleName, style)
lyr = mapnik.Layer('layer')
lyr.srs = layerSrs
lyr.datasource = mapnik.Gdal(
base=None, file=self._path, band=band, extent=extent, nodata=nodata)
lyr.styles.append(styleName)
m.layers.append(lyr)
def addPreviewToMap(self, name, scaleDenoms, filter, symbol_type,
datasource, layerSRS, prevColor):
s = mapnik.Style()
r = mapnik.Rule()
if symbol_type == 'polygon':
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color(prevColor))
r.symbols.append(polygon_symbolizer)
elif symbol_type == 'line':
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color(prevColor), 3)
r.symbols.append(line_symbolizer)
# elif symbol_type == 'text':
# t = mapnik.TextSymbolizer('FIELD_NAME', 'DejaVu Sans Book', 10, Color('black'))
# t.halo_fill = Color('white')
# t.halo_radius = 1
# t.label_placement = label_placement.LINE_PLACEMENT
# r.symbols.append(line_symbolizer)
else:
print symbol_type, 'has to be implemented to preview!!!'
if filter != None:
#f = mapnik.Expression("[waterway] != ''") #'Expression' stands for 'Filter' as this will be replaced in Mapnik3
r.filter = filter #f
if scaleDenoms != -1:
r.min_scale = scaleDenoms[0]
r.max_scale = scaleDenoms[1]
s.rules.append(r)
proof = self.tileParams.getMapnikMap().append_style(name, s)
layer = mapnik.Layer('world')
layer.datasource = datasource[1]
layer.srs = layerSRS
layer.styles.append(name)
self.tileParams.getMapnikMap().layers.append(layer)
def rgb_style():
rgb_symb = mapnik.RasterSymbolizer()
rgb_rule = mapnik.Rule()
rgb_rule.symbols.append(rgb_symb)
rgb_style = mapnik.Style()
rgb_style.rules.append(rgb_rule)
return rgb_style
def test_raster_with_alpha_blends_correctly_with_background():
WIDTH = 500
HEIGHT = 500
map = mapnik.Map(WIDTH, HEIGHT)
WHITE = mapnik.Color(255, 255, 255)
map.background = WHITE
style = mapnik.Style()
rule = mapnik.Rule()
symbolizer = mapnik.RasterSymbolizer()
symbolizer.scaling = mapnik.scaling_method.BILINEAR
rule.symbols.append(symbolizer)
style.rules.append(rule)
map.append_style('raster_style', style)
map_layer = mapnik.Layer('test_layer')
filepath = '../data/raster/white-alpha.png'
if 'gdal' in mapnik.DatasourceCache.plugin_names():
map_layer.datasource = mapnik.Gdal(file=filepath)
map_layer.styles.append('raster_style')
map.layers.append(map_layer)
map.zoom_all()
mim = mapnik.Image(WIDTH, HEIGHT)
mapnik.render(map, mim)
imdata = mim.tostring()
# All white is expected
eq_(get_unique_colors(mim),['rgba(254,254,254,255)'])
def style_map(self, Map):
style = mapnik.Style()
rule = mapnik.Rule()
sym = mapnik.RasterSymbolizer()
sym.opacity = self.opacity
colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
mapnik.Color('white'))
# colorizer.epsilon = 0.001
if self.colormap:
for stop in self.colormap:
colorizer.add_stop(stop['quantity'],
mapnik.Color(stop['color'].encode('ascii')))
sym.colorizer = colorizer
rule.symbols.append(sym)
style.rules.append(rule)
Map.append_style('Raster Style', style)
lyr = mapnik.Layer('GDAL Layer from TIFF', self.layer_srs)
lyr.datasource = mapnik.Gdal(base=os.path.dirname(self.vrt_path),
file=os.path.basename(self.vrt_path),
band=self.mapnik_band)
lyr.styles.append('Raster Style')
Map.layers.append(lyr)
return Map
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 create_grid_map(width,height):
places_ds = mapnik.PointDatasource()
places_ds.add_point(143.10,-38.60,'Name','South East')
places_ds.add_point(142.48,-38.60,'Name','South West')
places_ds.add_point(142.48,-38.38,'Name','North West')
places_ds.add_point(143.10,-38.38,'Name','North East')
s = mapnik.Style()
r = mapnik.Rule()
#symb = mapnik.PointSymbolizer()
symb = mapnik.MarkersSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
label = mapnik.TextSymbolizer(mapnik.Expression('[Name]'),
'DejaVu Sans Book',
10,
mapnik.Color('black')
)
label.allow_overlap = True
label.displacement = (0,-10)
#r.symbols.append(label)
s.rules.append(r)
lyr = mapnik.Layer('Places')
lyr.datasource = places_ds
lyr.styles.append('places_labels')
m = mapnik.Map(width,height)
m.append_style('places_labels',s)
m.layers.append(lyr)
return m
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 addPreviewOfGeneralizedGeometriesToMap(self, table_name, symbol_type,
layerSRS, name):
genColor = 'rgb(0%,0%,100%)'
s = mapnik.Style()
r = mapnik.Rule()
if symbol_type == 'polygon':
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color(genColor))
r.symbols.append(polygon_symbolizer)
elif symbol_type == 'line':
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color(genColor), 2)
r.symbols.append(line_symbolizer)
else:
print symbol_type, 'has to be implemented to preview!!!'
s.rules.append(r)
self.tileParams.getMapnikMap().append_style(name, s)
lyr = mapnik.Layer('Generalized geometry from PostGIS')
lyr.datasource = mapnik.PostGIS(host='localhost',
user='******',
password='******',
dbname='meingis',
table='(select geom from ' +
table_name + ' ) as geometries')
lyr.srs = layerSRS
lyr.styles.append(name)
self.tileParams.getMapnikMap().layers.append(lyr)
def create_rule(expression, color):
rule = mapnik.Rule()
rule.filter = mapnik.Expression(expression)
point_symbolizer = mapnik.MarkersSymbolizer()
point_symbolizer.fill = mapnik.Color(*color)
rule.symbols.append(point_symbolizer)
return rule
def test_raster_warping_does_not_overclip_source():
lyrSrs = "+init=epsg:32630"
mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
lyr = mapnik.Layer('dataraster', lyrSrs)
if 'gdal' in mapnik.DatasourceCache.plugin_names():
lyr.datasource = mapnik.Gdal(
file = '../data/raster/dataraster.tif',
band = 1,
)
sym = mapnik.RasterSymbolizer()
sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE, mapnik.Color(255,255,0))
rule = mapnik.Rule()
rule.symbols.append(sym)
style = mapnik.Style()
style.rules.append(rule)
_map = mapnik.Map(256,256, mapSrs)
_map.background=mapnik.Color('white')
_map.append_style('foo', style)
lyr.styles.append('foo')
_map.layers.append(lyr)
_map.zoom_to_box(mapnik.Box2d(3,42,4,43))
im = mapnik.Image(_map.width,_map.height)
mapnik.render(_map, im)
expected_file = './images/support/raster_warping_does_not_overclip_source.png'
actual_file = '/tmp/' + os.path.basename(expected_file)
im.save(actual_file,'png32')
if not os.path.exists(expected_file) or os.environ.get('UPDATE'):
im.save(expected_file,'png32')
actual = mapnik.Image.open(actual_file)
expected = mapnik.Image.open(expected_file)
eq_(actual.tostring('png32'),expected.tostring('png32'), 'failed comparing actual (%s) and expected (%s)' % (actual_file,expected_file))
def __init__(self):
BaseWMSFactory.__init__(self)
for data in datas:
name = data['name']
title = data['long_name']
data = base_path+"/ecohealth/"+name+'.asc'
layer = mapnik.Layer(name,"+init=epsg:4326")
layer.datasource = mapnik.Gdal(file=str(data),band=1)
layer.title = title
layer.queryable = True
layer.wms_srs = None
style = mapnik.Style()
rule = mapnik.Rule()
sym = mapnik.RasterSymbolizer()
sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, mapnik.Color("transparent"))
scale = getEcohealthScale(name)
for color in scale:
sym.colorizer.add_stop(color['stop'], mapnik.Color(*color['color']))
rule.symbols.append(sym)
style.rules.append(rule)
self.register_style(name,style)
self.register_layer(layer, name, (name,))
self.finalize()
def __init__(self, id, file, fill_color, stroke_color, stroke_width):
"""Creates a shape layer."""
super(ShapeLayer, self).__init__()
self.id = id
self.file = file
self.fill_color = fill_color
self.stroke_color = stroke_color
self.stroke_width = stroke_width
ds = mapnik.Shapefile(file=(os.path.splitext(file)[0]))
srs = self._srs(file)
self.mapnik_layer = mapnik.Layer('Shapefile Layer', srs)
self.mapnik_layer.datasource = ds
self.mapnik_layer.maximum_extent = self._extent(file)
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color(str(fill_color))
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color(str(stroke_color))
line_symbolizer.stroke_width = float(stroke_width)
rule = mapnik.Rule()
rule.symbols.append(polygon_symbolizer)
rule.symbols.append(line_symbolizer)
style = mapnik.Style()
style.rules.append(rule)
self.mapnik_style = style
self.mapnik_layer.styles.append('Shapefile Layer')
def _render_shape_file(self, shape_file, color, line_width):
LOG.debug("render_shape_file")
shape_file.flush()
shpid = os.path.basename(shape_file.get_filepath())
s, r = mapnik.Style(), mapnik.Rule()
if ocitysmap.get_mapnik_major_version() == 2:
r.symbols.append(mapnik.PolygonSymbolizer(color))
r.symbols.append(mapnik.LineSymbolizer(color, line_width))
else:
poly_sym = mapnik.PolygonSymbolizer()
poly_sym.fill = color
r.symbols.append(poly_sym)
line_sym = mapnik.LineSymbolizer()
line_sym.stroke = color
line_sym.stroke_width = float(line_width)
r.symbols.append(line_sym)
s.rules.append(r)
self._map.append_style('style_%s' % shpid, s)
layer = mapnik.Layer(shpid)
layer.datasource = mapnik.Shapefile(file=shape_file.get_filepath())
layer.styles.append('style_%s' % shpid)
self._map.layers.append(layer)
def create_map_and_append_symbolyzer(sym):
srs = '+init=epsg:32630'
lyr = mapnik.Layer('arrows')
try:
lyr.datasource = mapnik.Shapefile(file='../data/shp/arrows.shp', )
lyr.srs = srs
_map = mapnik.Map(256, 256, srs)
style = mapnik.Style()
rule = mapnik.Rule()
rule.symbols.append(sym)
# put a test symbolizer to see what is the azimuth being read
ts = mapnik.TextSymbolizer(mapnik.Expression('[azimuth]'),
"DejaVu Sans Book", 10,
mapnik.Color("black"))
ts.allow_overlap = True
rule.symbols.append(ts)
style.rules.append(rule)
_map.append_style('foo', style)
lyr.styles.append('foo')
_map.layers.append(lyr)
_map.zoom_to_box(mapnik.Box2d(0, 0, 8, 8))
return _map
except RuntimeError, e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(e)
def test_that_coordinates_do_not_overflow_and_polygon_is_rendered():
expected_color = mapnik.Color('white')
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
ds.add_feature(mapnik.Feature.from_geojson(json.dumps(geojson), context))
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.PolygonSymbolizer()
sym.fill = expected_color
sym.clip = False
r.symbols.append(sym)
s.rules.append(r)
lyr = mapnik.Layer('Layer')
lyr.datasource = ds
lyr.styles.append('style')
m = mapnik.Map(256, 256)
m.background_color = mapnik.Color('black')
m.append_style('style', s)
m.layers.append(lyr)
# 17/20864/45265.png
m.zoom_to_box(
mapnik.Box2d(-13658379.710221574, 6197514.253362091,
-13657768.213995293, 6198125.749588372))
# works 15/5216/11316.png
#m.zoom_to_box(mapnik.Box2d(-13658379.710221574,6195679.764683247,-13655933.72531645,6198125.749588372))
im = mapnik.Image(256, 256)
mapnik.render(m, im)
eq_(im.get_pixel(128, 128), expected_color.packed())
