def test_render_grid3():
""" test using feature id"""
width,height = 256,256
sym = mapnik.MarkersSymbolizer()
sym.width = mapnik.Expression('10')
sym.height = mapnik.Expression('10')
m = create_grid_map(width,height,sym)
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
grid = mapnik.Grid(m.width,m.height,key='__id__')
mapnik.render_layer(m,grid,layer=0,fields=['__id__','Name'])
utf1 = grid.encode('utf',resolution=4)
eq_(utf1,grid_feat_id3,show_grids('id-markers',utf1,grid_feat_id3))
# check a full view is the same as a full image
grid_view = grid.view(0,0,width,height)
# for kicks check at full res too
utf3 = grid.encode('utf',resolution=1)
utf4 = grid_view.encode('utf',resolution=1)
eq_(utf3['grid'],utf4['grid'])
eq_(utf3['keys'],utf4['keys'])
eq_(utf3['data'],utf4['data'])
eq_(resolve(utf4,0,0),None)
# resolve some center points in the
# resampled view
utf5 = grid_view.encode('utf',resolution=4)
eq_(resolve(utf5,25,10),{"Name": "North West","__id__": 3})
eq_(resolve(utf5,25,46),{"Name": "North East","__id__": 4})
eq_(resolve(utf5,38,10),{"Name": "South West","__id__": 2})
eq_(resolve(utf5,38,46),{"Name": "South East","__id__": 1})
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 test_expressions_for_thruthyness():
context = mapnik.Context()
for eq in truthyness:
f = mapnik.Feature(context, 0)
f["prop"] = eq[0]
eq_(f["prop"], eq[0])
if eq[0] is None:
eq_(f["prop"] is None, True)
else:
eq_(isinstance(f['prop'], eq[2]), True,
'%s is not an instance of %s' % (f['prop'], eq[2]))
expr = mapnik.Expression("[prop]")
eq_(expr.to_bool(f), eq[1])
expr = mapnik.Expression("not [prop]")
eq_(expr.to_bool(f), not eq[1])
expr = mapnik.Expression("! [prop]")
eq_(expr.to_bool(f), not eq[1])
# also test if feature does not have property at all
f2 = mapnik.Feature(context, 1)
# no property existing will return value_null since
# https://github.com/mapnik/mapnik/commit/562fada9d0f680f59b2d9f396c95320a0d753479#include/mapnik/feature.hpp
eq_(f2["prop"] is None, True)
expr = mapnik.Expression("[prop]")
eq_(expr.evaluate(f2), None)
eq_(expr.to_bool(f2), False)
def test_shieldsymbolizer_init():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
eq_(s.anchor, (
0.0,
0.5,
))
eq_(s.displacement, (0.0, 0.0))
eq_(s.allow_overlap, False)
eq_(s.avoid_edges, False)
eq_(s.character_spacing, 0)
eq_(str(s.name), str(mapnik.Expression('[Field Name]')))
eq_(s.face_name, 'DejaVu Sans Bold')
eq_(s.allow_overlap, False)
eq_(s.fill, mapnik.Color('#000000'))
eq_(s.force_odd_labels, False)
eq_(s.halo_fill, mapnik.Color('rgb(255,255,255)'))
eq_(s.halo_radius, 0)
eq_(s.label_placement, mapnik.label_placement.POINT_PLACEMENT)
eq_(s.minimum_distance, 0.0)
eq_(s.text_ratio, 0)
eq_(s.text_size, 6)
eq_(s.wrap_width, 0)
eq_(s.vertical_alignment, mapnik.vertical_alignment.MIDDLE)
eq_(s.label_spacing, 0)
eq_(s.label_position_tolerance, 0)
# 22.5 * M_PI/180.0 initialized by default
assert_almost_equal(s.max_char_angle_delta, 0.39269908169872414)
eq_(s.wrap_character, ' ')
eq_(s.text_transform, mapnik.text_transform.NONE)
eq_(s.line_spacing, 0)
eq_(s.character_spacing, 0)
# r1341
eq_(s.wrap_before, False)
eq_(s.horizontal_alignment, mapnik.horizontal_alignment.MIDDLE)
eq_(s.justify_alignment, mapnik.justify_alignment.MIDDLE)
eq_(s.opacity, 1.0)
# r2300
eq_(s.minimum_padding, 0.0)
# was mixed with s.opacity
eq_(s.text_opacity, 1.0)
eq_(s.shield_displacement, (0.0, 0.0))
# TODO - the pattern in bindings seems to be to get/set
# strings for PathExpressions... should we pass objects?
eq_(s.filename, '../data/images/dummy.png')
eq_(s.transform, 'matrix(1, 0, 0, 1, 0, 0)')
raise Todo(
"FontSet pickling support needed: http://trac.mapnik.org/ticket/348")
eq_(s.fontset, '')
def test_textsymbolizer_init():
ts = mapnik.TextSymbolizer(mapnik.Expression('[Field_Name]'), 'Font Name',
8, mapnik.Color('black'))
eq_(str(ts.name), str(mapnik.Expression('[Field_Name]')))
eq_(ts.face_name, 'Font Name')
eq_(ts.text_size, 8)
eq_(ts.fill, mapnik.Color('black'))
eq_(ts.label_placement, mapnik.label_placement.POINT_PLACEMENT)
def test_float_precision():
context = mapnik.Context()
context.push('num')
f = mapnik.Feature(context, 0)
f["num"] = 1.0000
eq_(f["num"], 1.0000)
expr = mapnik.Expression("[num] = 1.0000")
eq_(expr.evaluate(f), True)
expr = mapnik.Expression("[num].match('.*0$')")
eq_(expr.evaluate(f), True)
expr = mapnik.Expression("[num].match('.*0$')")
eq_(expr.evaluate(f), True)
def test_markers_symbolizer():
p = mapnik.MarkersSymbolizer()
eq_(p.allow_overlap, False)
eq_(p.opacity,1.0)
eq_(p.fill_opacity,None)
eq_(p.filename,'shape://ellipse')
eq_(p.placement,mapnik.marker_placement.POINT_PLACEMENT)
eq_(p.multi_policy,mapnik.marker_multi_policy.EACH)
eq_(p.fill,None)
eq_(p.ignore_placement,False)
eq_(p.spacing,100)
eq_(p.max_error,0.2)
eq_(p.width,None)
eq_(p.height,None)
eq_(p.transform,'')
eq_(p.clip,True)
eq_(p.comp_op,mapnik.CompositeOp.src_over)
p.width = mapnik.Expression('12')
p.height = mapnik.Expression('12')
eq_(str(p.width),'12')
eq_(str(p.height),'12')
p.width = mapnik.Expression('[field] + 2')
p.height = mapnik.Expression('[field] + 2')
eq_(str(p.width),'([field]+2)')
eq_(str(p.height),'([field]+2)')
stroke = mapnik.Stroke()
stroke.color = mapnik.Color('black')
stroke.width = 1.0
p.stroke = stroke
p.fill = mapnik.Color('white')
p.allow_overlap = True
p.opacity = 0.5
p.fill_opacity = 0.5
p.placement = mapnik.marker_placement.LINE_PLACEMENT
p.multi_policy = mapnik.marker_multi_policy.WHOLE
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.fill_opacity, 0.5)
eq_(p.multi_policy,mapnik.marker_multi_policy.WHOLE)
eq_(p.placement,mapnik.marker_placement.LINE_PLACEMENT)
#https://github.com/mapnik/mapnik/issues/1285
#https://github.com/mapnik/mapnik/issues/1427
p.marker_type = 'arrow'
eq_(p.marker_type,'shape://arrow')
eq_(p.filename,'shape://arrow')
def getPointStyle():
# add style
style = mapnik.Style() # style object to hold rules
rule = mapnik.Rule() # rule object to hold symbolizers
marker = mapnik.MarkersSymbolizer()
# marker.fill_opacity = .5
# marker.opacity = .5
marker.height = mapnik.Expression("3")
marker.width = mapnik.Expression("3")
marker.fill = mapnik.Color('black')
rule.symbols.append(marker)
style.rules.append(rule)
return style
def test_expressions_with_null_equality():
for eq in null_equality:
context = mapnik.Context()
f = mapnik.Feature(context,0)
f["prop"] = eq[0]
eq_(f["prop"],eq[0])
if eq[0] is None:
eq_(f["prop"] is None, True)
else:
eq_(isinstance(f['prop'],eq[2]),True,'%s is not an instance of %s' % (f['prop'],eq[2]))
expr = mapnik.Expression("[prop] = null")
eq_(expr.evaluate(f),eq[1])
expr = mapnik.Expression("[prop] is null")
eq_(expr.evaluate(f),eq[1])
def test_textsymbolizer_pickle():
ts = mapnik.TextSymbolizer(mapnik.Expression('[Field_Name]'), 'Font Name',
8, mapnik.Color('black'))
eq_(str(ts.name), str(mapnik.Expression('[Field_Name]')))
eq_(ts.face_name, 'Font Name')
eq_(ts.text_size, 8)
eq_(ts.fill, mapnik.Color('black'))
raise Todo("text_symbolizer pickling currently disabled")
ts2 = pickle.loads(pickle.dumps(ts, pickle.HIGHEST_PROTOCOL))
eq_(ts.name, ts2.name)
eq_(ts.face_name, ts2.face_name)
eq_(ts.allow_overlap, ts2.allow_overlap)
eq_(ts.displacement, ts2.displacement)
eq_(ts.anchor, ts2.anchor)
eq_(ts.fill, ts2.fill)
eq_(ts.force_odd_labels, ts2.force_odd_labels)
eq_(ts.halo_fill, ts2.halo_fill)
eq_(ts.halo_radius, ts2.halo_radius)
eq_(ts.label_placement, ts2.label_placement)
eq_(ts.minimum_distance, ts2.minimum_distance)
eq_(ts.text_ratio, ts2.text_ratio)
eq_(ts.text_size, ts2.text_size)
eq_(ts.wrap_width, ts2.wrap_width)
eq_(ts.vertical_alignment, ts2.vertical_alignment)
eq_(ts.label_spacing, ts2.label_spacing)
eq_(ts.label_position_tolerance, ts2.label_position_tolerance)
# 22.5 * M_PI/180.0 initialized by default
assert_almost_equal(s.max_char_angle_delta, 0.39269908169872414)
eq_(ts.wrap_character, ts2.wrap_character)
eq_(ts.text_transform, ts2.text_transform)
eq_(ts.line_spacing, ts2.line_spacing)
eq_(ts.character_spacing, ts2.character_spacing)
# r1341
eq_(ts.wrap_before, ts2.wrap_before)
eq_(ts.horizontal_alignment, ts2.horizontal_alignment)
eq_(ts.justify_alignment, ts2.justify_alignment)
eq_(ts.opacity, ts2.opacity)
# r2300
eq_(s.minimum_padding, 0.0)
raise Todo(
"FontSet pickling support needed: http://trac.mapnik.org/ticket/348")
eq_(ts.fontset, ts2.fontset)
def test_renders_with_agg():
sym = mapnik.GlyphSymbolizer("DejaVu Sans Condensed",
mapnik.Expression("'í'"))
sym.allow_overlap = True
sym.angle = mapnik.Expression(
"[azimuth]+90") #+90 so the top of the glyph points upwards
sym.size = mapnik.Expression("[value]")
sym.color = mapnik.Expression("'#ff0000'")
_map = create_map_and_append_symbolyzer(sym)
if _map:
im = mapnik.Image(_map.width, _map.height)
mapnik.render(_map, im)
save_data('agg_glyph_symbolizer.png', im.tostring('png'))
assert contains_word('\xff\x00\x00\xff', im.tostring())
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 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 test_regex_replace():
context = mapnik.Context()
context.push('name')
f = mapnik.Feature(context, 0)
f["name"] = 'test'
expr = mapnik.Expression("[name].replace('(\\B)|( )','$1 ')")
eq_(expr.evaluate(f), 't e s t')
def test_unicode_regex_match():
context = mapnik.Context()
context.push('name')
f = mapnik.Feature(context, 0)
f["name"] = 'Québec'
expr = mapnik.Expression("[name].match('Québec')")
eq_(expr.evaluate(f), True) # 1 == True
def test_text_symbolizer():
s = mapnik.TextSymbolizer()
eq_(s.comp_op, mapnik.CompositeOp.src_over)
eq_(s.clip, True)
eq_(s.halo_rasterizer, mapnik.halo_rasterizer.FULL)
# https://github.com/mapnik/mapnik/issues/1420
eq_(s.text_transform, mapnik.text_transform.NONE)
# https://github.com/mapnik/mapnik/issues/1427
eq_(s.wrap_char, ord(' '))
eq_(s.wrap_character, ord(' '))
s.wrap_char = ord('\n')
eq_(s.wrap_char, ord('\n'))
eq_(s.wrap_character, ord('\n'))
eq_(s.format.wrap_character, ord('\n'))
s.wrap_character = ord('\r')
eq_(s.wrap_char, ord('\r'))
eq_(s.wrap_character, ord('\r'))
eq_(s.format.wrap_character, ord('\r'))
s.format.wrap_character = ord(' ')
eq_(s.wrap_char, ord(' '))
eq_(s.wrap_character, ord(' '))
eq_(s.format.wrap_character, ord(' '))
# old args required method
ts = mapnik.TextSymbolizer(mapnik.Expression('[Field_Name]'), 'Font Name',
8, mapnik.Color('black'))
# eq_(str(ts.name), str(mapnik2.Expression('[Field_Name]'))) name field is no longer supported
eq_(ts.format.face_name, 'Font Name')
eq_(ts.format.text_size, 8)
eq_(ts.format.fill, mapnik.Color('black'))
eq_(ts.properties.label_placement, mapnik.label_placement.POINT_PLACEMENT)
eq_(ts.properties.horizontal_alignment, mapnik.horizontal_alignment.AUTO)
def getTextStyle(fieldname):
style = mapnik.Style() # style object to hold rules
rule = mapnik.Rule() # rule object to hold symbolizers
# print(help(mapnik.TextSymbolizer))
print(mapnik.mapnik_version())
symbolizer = mapnik.TextSymbolizer(
mapnik.Expression('[' + fieldname + ']'), 'DejaVu Sans Book', 10,
mapnik.Color('black'))
# symbolizer = mapnik.TextSymbolizer()
# print(symbolizer, dir(symbolizer))
# print(symbolizer.properties.format_tree.text)
# symbolizer.face_name = mapnik.FormattingText('DejaVu Sans Book')
# symbolizer.face_name = 'DejaVu Sans Book'
# symbolizer.properties.format_tree = mapnik.FormattingText('DejaVu Sans Book')
# symbolizer.name = mapnik.Expression('['+fieldname+']')
symbolizer.halo_fill = mapnik.Color('white')
symbolizer.halo_radius = 1
symbolizer.label_placement = label_placement.LINE_PLACEMENT # POINT_PLACEMENT is default
symbolizer.allow_overlap = False
symbolizer.avoid_edges = True
rule.symbols.append(symbolizer)
style.rules.append(rule)
return style
def rule(symbol, filter=None):
rul = mapnik.Rule()
if filter is not None:
rul.filter = mapnik.Expression(filter)
rul.symbols.append(symbol)
return rul
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_float_precision():
context = mapnik.Context()
context.push('num')
f = mapnik.Feature(context, 0)
f["num1"] = 1.0000
f["num2"] = 1.0001
eq_(f["num1"], 1.0000)
eq_(f["num2"], 1.0001)
expr = mapnik.Expression("[num1] = 1.0000")
eq_(expr.evaluate(f), True)
expr = mapnik.Expression("[num1].match('1')")
eq_(expr.evaluate(f), True)
expr = mapnik.Expression("[num2] = 1.0001")
eq_(expr.evaluate(f), True)
expr = mapnik.Expression("[num2].match('1.0001')")
eq_(expr.evaluate(f), True)
def test_feature_expression_evaluation_attr_with_spaces():
f = mapnik.Feature(1)
f['name with space'] = u'a'
eq_(f['name with space'], u'a')
expr = mapnik.Expression("[name with space]='a'")
eq_(str(expr), "([name with space]='a')")
eq_(expr.evaluate(f), True)
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 create_roi_output_style(attr_name):
qgis_style_file = os.path.join(os.path.dirname(__file__),
"plot_data/roi_pred_classes_4.qml")
symbols = {}
with open(qgis_style_file, 'rb') as qsf:
doc = etree.parse(qsf)
for range in doc.xpath('//range'):
upper = range.attrib['upper']
lower = range.attrib['lower']
label = range.attrib['label']
symbol = range.attrib['symbol']
symbols[symbol] = {
"lower": float(lower),
"upper": float(upper),
"label": str(label),
}
for node in doc.xpath("//prop[@k='color']"):
layer = node.getparent()
sym = layer.getparent()
sym_name = sym.attrib['name']
str_color = node.attrib["v"]
c = str_color.split(",")
symbols[sym_name]["color"] = mapnik.Color(
"rgb(%d,%d,%d)" % (int(c[0]), int(c[1]), int(c[2])))
style = mapnik.Style()
for sname in symbols:
r = mapnik.Rule()
psym = mapnik.MarkersSymbolizer()
psym.fill = symbols[sname]["color"]
psym.width = mapnik.Expression('6')
psym.height = mapnik.Expression('6')
psym.stroke = mapnik.Stroke(mapnik.Color('white'), 0)
r.symbols.append(psym)
upper = symbols[sname]["upper"]
lower = symbols[sname]["lower"]
f = mapnik.Filter("[%s] >= %f and [%s] < %f" %
(attr_name, lower, attr_name, upper))
r.filter = f
style.opacity = 0.8
style.rules.append(r)
return style
def test_render_grid():
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(256,256)
m.append_style('places_labels',s)
m.layers.append(lyr)
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
grid = mapnik.render_grid(m,0,key='Name',resolution=4,fields=['Name'])
eq_(grid,grid_correct)
eq_(resolve(grid,0,0),None)
# check every pixel of the nw symbol
expected = {"Name": "North West"}
# top row
eq_(resolve(grid,23,9),expected)
eq_(resolve(grid,23,10),expected)
eq_(resolve(grid,23,11),expected)
# core
eq_(resolve(grid,24,8),expected)
eq_(resolve(grid,24,9),expected)
eq_(resolve(grid,24,10),expected)
eq_(resolve(grid,24,11),expected)
eq_(resolve(grid,24,12),expected)
eq_(resolve(grid,25,8),expected)
eq_(resolve(grid,25,9),expected)
eq_(resolve(grid,25,10),expected)
eq_(resolve(grid,25,11),expected)
eq_(resolve(grid,25,12),expected)
# bottom row
eq_(resolve(grid,26,9),expected)
eq_(resolve(grid,26,10),expected)
eq_(resolve(grid,26,11),expected)
def test_shieldsymbolizer_modify():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
# transform expression
s.transform = "rotate(30+[a]) scale(2*[sx] [sy])"
eq_(s.transform, "rotate((30+[a])) scale(2*[sx], [sy])")
def test_expressions_with_null_equality2():
for eq in null_equality:
context = mapnik.Context()
f = mapnik.Feature(context,0)
f["prop"] = eq[0]
eq_(f["prop"],eq[0])
if eq[0] is None:
eq_(f["prop"] is None, True)
else:
eq_(isinstance(f['prop'],eq[2]),True,'%s is not an instance of %s' % (f['prop'],eq[2]))
# TODO - support `is not` syntax:
# https://github.com/mapnik/mapnik/issues/796
expr = mapnik.Expression("not [prop] is null")
eq_(expr.evaluate(f),not eq[1])
# https://github.com/mapnik/mapnik/issues/1642
expr = mapnik.Expression("[prop] != null")
eq_(expr.evaluate(f),not eq[1])
def test_unicode_regex_replace():
context = mapnik.Context()
context.push('name')
f = mapnik.Feature(context, 0)
f["name"] = 'Québec'
expr = mapnik.Expression("[name].replace('(\\B)|( )','$1 ')")
# will fail if -DBOOST_REGEX_HAS_ICU is not defined
eq_(expr.evaluate(f), u'Q u é b e c')
def test_string_matching_on_precision():
context = mapnik.Context()
context.push('num')
f = mapnik.Feature(context, 0)
f["num"] = "1.0000"
eq_(f["num"], "1.0000")
expr = mapnik.Expression("[num].match('.*(^0|00)$')")
eq_(expr.evaluate(f), True)
def render_image(conn, folder, pic):
m = mapnik.Map(450,450)
m.background = mapnik.Color("White")
r = mapnik.Rule()
s = mapnik.Style()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('Grey')
r.symbols.append(polygon_symbolizer)
productivi_less_30 = mapnik.Rule()
productivi_less_30.filter = mapnik.Expression("[productivi]<=30")
productivi_less_30_polygon_symbolizer = mapnik.PolygonSymbolizer()
productivi_less_30_polygon_symbolizer.fill = mapnik.Color('#ff5959')
productivi_less_30.symbols.append(productivi_less_30_polygon_symbolizer)
productivi_30_70 = mapnik.Rule()
productivi_30_70.filter = mapnik.Expression("([productivi]>=31) and ([productivi]<70)")
productivi_30_70_polygon_symbolizer = mapnik.PolygonSymbolizer()
productivi_30_70_polygon_symbolizer.fill = mapnik.Color('#ffa159')
productivi_30_70.symbols.append(productivi_30_70_polygon_symbolizer)
productivi_more_then_70 = mapnik.Rule()
productivi_more_then_70.filter = mapnik.Expression("[productivi]>=70")
productivi_more_then_70_polygon_symbolizer = mapnik.PolygonSymbolizer()
productivi_more_then_70_polygon_symbolizer.fill = mapnik.Color('#d0ff59')
productivi_more_then_70.symbols.append(productivi_more_then_70_polygon_symbolizer)
s.rules.append(productivi_less_30)
s.rules.append(productivi_30_70)
s.rules.append(productivi_more_then_70)
m.append_style('My Style',s)
layer = mapnik.Layer("Data from PostGIS")
layer.datasource = mapnik.PostGIS(dbname=conn[1], host=conn[0], port=conn[2], table = conn[5], user=conn[3], password=conn[4])
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, folder + pic, 'png')
return pic
def test_division_by_zero():
expr = mapnik.Expression('[a]/[b]')
c = mapnik.Context()
c.push('a')
c.push('b')
f = mapnik.Feature(c, 0)
f['a'] = 1
f['b'] = 0
eq_(expr.evaluate(f), None)
