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)