# #!/usr/bin/env python # # -*- coding: utf-8 -*- # import os # from nose.tools import * # from utilities import execution_path, run_all # import tempfile # import mapnik # def setup(): # # All of the paths used are relative, if we run the tests # # from another directory we need to chdir() # os.chdir(execution_path('.')) # def test_debug_symbolizer(): # s = mapnik.DebugSymbolizer() # eq_(s.mode,mapnik.debug_symbolizer_mode.collision) # def test_raster_symbolizer(): # s = mapnik.RasterSymbolizer() # eq_(s.comp_op,mapnik.CompositeOp.src_over) # note: mode is deprecated # eq_(s.scaling,mapnik.scaling_method.NEAR) # eq_(s.opacity,1.0) # eq_(s.colorizer,None) # eq_(s.filter_factor,-1) # eq_(s.mesh_size,16) # eq_(s.premultiplied,None) # s.premultiplied = True # eq_(s.premultiplied,True) # def test_line_pattern(): # s = mapnik.LinePatternSymbolizer(mapnik.PathExpression('../data/images/dummy.png')) # eq_(s.filename, '../data/images/dummy.png') # eq_(s.smooth,0.0) # eq_(s.transform,'') # eq_(s.offset,0.0) # eq_(s.comp_op,mapnik.CompositeOp.src_over) # eq_(s.clip,True) # def test_line_symbolizer(): # s = mapnik.LineSymbolizer() # eq_(s.rasterizer, mapnik.line_rasterizer.FULL) # eq_(s.smooth,0.0) # eq_(s.comp_op,mapnik.CompositeOp.src_over) # eq_(s.clip,True) # eq_(s.stroke.width, 1) # eq_(s.stroke.opacity, 1) # eq_(s.stroke.color, mapnik.Color('black')) # eq_(s.stroke.line_cap, mapnik.line_cap.BUTT_CAP) # eq_(s.stroke.line_join, mapnik.line_join.MITER_JOIN) # l = mapnik.LineSymbolizer(mapnik.Color('blue'), 5.0) # eq_(l.stroke.width, 5) # eq_(l.stroke.opacity, 1) # eq_(l.stroke.color, mapnik.Color('blue')) # eq_(l.stroke.line_cap, mapnik.line_cap.BUTT_CAP) # eq_(l.stroke.line_join, mapnik.line_join.MITER_JOIN) # s = mapnik.Stroke(mapnik.Color('blue'), 5.0) # l = mapnik.LineSymbolizer(s) # eq_(l.stroke.width, 5) # eq_(l.stroke.opacity, 1) # eq_(l.stroke.color, mapnik.Color('blue')) # eq_(l.stroke.line_cap, mapnik.line_cap.BUTT_CAP) # eq_(l.stroke.line_join, mapnik.line_join.MITER_JOIN) # def test_line_symbolizer_stroke_reference(): # l = mapnik.LineSymbolizer(mapnik.Color('green'),0.1) # l.stroke.add_dash(.1,.1) # l.stroke.add_dash(.1,.1) # eq_(l.stroke.get_dashes(), [(.1,.1),(.1,.1)]) # eq_(l.stroke.color,mapnik.Color('green')) # eq_(l.stroke.opacity,1.0) # assert_almost_equal(l.stroke.width,0.1) # # https://github.com/mapnik/mapnik/issues/1427 # def test_stroke_dash_api(): # stroke = mapnik.Stroke() # dashes = [(1.0,1.0)] # stroke.dasharray = dashes # eq_(stroke.dasharray, dashes) # stroke.add_dash(.1,.1) # dashes.append((.1,.1)) # eq_(stroke.dasharray, dashes) # 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) # # 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 test_shield_symbolizer_init(): # s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../data/images/dummy.png')) # eq_(s.comp_op,mapnik.CompositeOp.src_over) # eq_(s.clip,True) # 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(mapnik2.Expression('[Field Name]'))) name field is no longer supported # eq_(s.face_name, 'DejaVu Sans Bold') # eq_(s.allow_overlap, False) # eq_(s.fill, mapnik.Color('#000000')) # 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.AUTO) # 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.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.AUTO) # eq_(s.justify_alignment, mapnik.justify_alignment.AUTO) # 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') # # 11c34b1: default transform list is empty, not identity matrix # eq_(s.transform, '') # eq_(s.fontset, None) # # ShieldSymbolizer missing image file # # images paths are now PathExpressions are evaluated at runtime # # so it does not make sense to throw... # #@raises(RuntimeError) # #def test_shieldsymbolizer_missing_image(): # # s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../#data/images/broken.png')) # def test_shield_symbolizer_modify(): # s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../data/images/dummy.png')) # # transform expression # def check_transform(expr, expect_str=None): # s.transform = expr # eq_(s.transform, expr if expect_str is None else expect_str) # check_transform("matrix(1 2 3 4 5 6)", "matrix(1, 2, 3, 4, 5, 6)") # check_transform("matrix(1, 2, 3, 4, 5, 6 +7)", "matrix(1, 2, 3, 4, 5, (6+7))") # check_transform("rotate([a])") # check_transform("rotate([a] -2)", "rotate(([a]-2))") # check_transform("rotate([a] -2 -3)", "rotate([a], -2, -3)") # check_transform("rotate([a] -2 -3 -4)", "rotate(((([a]-2)-3)-4))") # check_transform("rotate([a] -2, 3, 4)", "rotate(([a]-2), 3, 4)") # check_transform("translate([tx]) rotate([a])") # check_transform("scale([sx], [sy]/2)") # # TODO check expected failures # def test_point_symbolizer(): # p = mapnik.PointSymbolizer() # eq_(p.filename,'') # eq_(p.transform,'') # eq_(p.opacity,1.0) # eq_(p.allow_overlap,False) # eq_(p.ignore_placement,False) # eq_(p.comp_op,mapnik.CompositeOp.src_over) # eq_(p.placement, mapnik.point_placement.CENTROID) # p = mapnik.PointSymbolizer(mapnik.PathExpression("../data/images/dummy.png")) # p.allow_overlap = True # p.opacity = 0.5 # p.ignore_placement = True # p.placement = mapnik.point_placement.INTERIOR # eq_(p.allow_overlap, True) # eq_(p.opacity, 0.5) # eq_(p.filename,'../data/images/dummy.png') # eq_(p.ignore_placement,True) # eq_(p.placement, mapnik.point_placement.INTERIOR) # 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') # # PointSymbolizer missing image file # # images paths are now PathExpressions are evaluated at runtime # # so it does not make sense to throw... # #@raises(RuntimeError) # #def test_pointsymbolizer_missing_image(): # # p = mapnik.PointSymbolizer(mapnik.PathExpression("../data/images/broken.png")) # def test_polygon_symbolizer(): # p = mapnik.PolygonSymbolizer() # eq_(p.smooth,0.0) # eq_(p.comp_op,mapnik.CompositeOp.src_over) # eq_(p.clip,True) # eq_(p.fill, mapnik.Color('gray')) # eq_(p.fill_opacity, 1) # p = mapnik.PolygonSymbolizer(mapnik.Color('blue')) # eq_(p.fill, mapnik.Color('blue')) # eq_(p.fill_opacity, 1) # def test_building_symbolizer_init(): # p = mapnik.BuildingSymbolizer() # eq_(p.fill, mapnik.Color('gray')) # eq_(p.fill_opacity, 1) # eq_(p.height,None) # def test_group_symbolizer_init(): # s = mapnik.GroupSymbolizer() # p = mapnik.GroupSymbolizerProperties() # l = mapnik.PairLayout() # l.item_margin = 5.0 # p.set_layout(l) # r = mapnik.GroupRule(mapnik.Expression("[name%1]")) # r.append(mapnik.PointSymbolizer()) # p.add_rule(r) # s.symbolizer_properties = p # eq_(s.comp_op,mapnik.CompositeOp.src_over) # def test_stroke_init(): # s = mapnik.Stroke() # eq_(s.width, 1) # eq_(s.opacity, 1) # eq_(s.color, mapnik.Color('black')) # eq_(s.line_cap, mapnik.line_cap.BUTT_CAP) # eq_(s.line_join, mapnik.line_join.MITER_JOIN) # eq_(s.gamma,1.0) # s = mapnik.Stroke(mapnik.Color('blue'), 5.0) # s.gamma = .5 # eq_(s.width, 5) # eq_(s.opacity, 1) # eq_(s.color, mapnik.Color('blue')) # eq_(s.gamma, .5) # eq_(s.line_cap, mapnik.line_cap.BUTT_CAP) # eq_(s.line_join, mapnik.line_join.MITER_JOIN) # def test_stroke_dash_arrays(): # s = mapnik.Stroke() # s.add_dash(1,2) # s.add_dash(3,4) # s.add_dash(5,6) # eq_(s.get_dashes(), [(1,2),(3,4),(5,6)]) # def test_map_init(): # m = mapnik.Map(256, 256) # eq_(m.width, 256) # eq_(m.height, 256) # eq_(m.srs, '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') # eq_(m.base, '') # eq_(m.maximum_extent, None) # eq_(m.background_image, None) # eq_(m.background_image_comp_op, mapnik.CompositeOp.src_over) # eq_(m.background_image_opacity, 1.0) # m = mapnik.Map(256, 256, '+proj=latlong') # eq_(m.srs, '+proj=latlong') # def test_map_style_access(): # m = mapnik.Map(256, 256) # sty = mapnik.Style() # m.append_style("style",sty) # styles = list(m.styles) # eq_(len(styles),1) # eq_(styles[0][0],'style') # # returns a copy so let's just check it is the right instance # eq_(isinstance(styles[0][1],mapnik.Style),True) # def test_map_maximum_extent_modification(): # m = mapnik.Map(256, 256) # eq_(m.maximum_extent, None) # m.maximum_extent = mapnik.Box2d() # eq_(m.maximum_extent, mapnik.Box2d()) # m.maximum_extent = None # eq_(m.maximum_extent, None) # # Map initialization from string # def test_map_init_from_string(): # map_string = ''' # # # My Style # # shape # ../../demo/data/boundaries # # # ''' # m = mapnik.Map(600, 300) # eq_(m.base, '') # try: # mapnik.load_map_from_string(m, map_string) # eq_(m.base, './') # mapnik.load_map_from_string(m, map_string, False, "") # this "" will have no effect # eq_(m.base, './') # tmp_dir = tempfile.gettempdir() # try: # mapnik.load_map_from_string(m, map_string, False, tmp_dir) # except RuntimeError: # pass # runtime error expected because shapefile path should be wrong and datasource will throw # eq_(m.base, tmp_dir) # tmp_dir will be set despite the exception because load_map mostly worked # m.base = 'foo' # mapnik.load_map_from_string(m, map_string, True, ".") # eq_(m.base, '.') # except RuntimeError, e: # # only test datasources that we have installed # if not 'Could not create datasource' in str(e): # raise RuntimeError(e) # # Color initialization # @raises(Exception) # Boost.Python.ArgumentError # def test_color_init_errors(): # c = mapnik.Color() # @raises(RuntimeError) # def test_color_init_errors(): # c = mapnik.Color('foo') # mapnik config # def test_color_init(): # c = mapnik.Color('blue') # eq_(c.a, 255) # eq_(c.r, 0) # eq_(c.g, 0) # eq_(c.b, 255) # eq_(c.to_hex_string(), '#0000ff') # c = mapnik.Color('#f2eff9') # eq_(c.a, 255) # eq_(c.r, 242) # eq_(c.g, 239) # eq_(c.b, 249) # eq_(c.to_hex_string(), '#f2eff9') # c = mapnik.Color('rgb(50%,50%,50%)') # eq_(c.a, 255) # eq_(c.r, 128) # eq_(c.g, 128) # eq_(c.b, 128) # eq_(c.to_hex_string(), '#808080') # c = mapnik.Color(0, 64, 128) # eq_(c.a, 255) # eq_(c.r, 0) # eq_(c.g, 64) # eq_(c.b, 128) # eq_(c.to_hex_string(), '#004080') # c = mapnik.Color(0, 64, 128, 192) # eq_(c.a, 192) # eq_(c.r, 0) # eq_(c.g, 64) # eq_(c.b, 128) # eq_(c.to_hex_string(), '#004080c0') # def test_color_equality(): # c1 = mapnik.Color('blue') # c2 = mapnik.Color(0,0,255) # c3 = mapnik.Color('black') # c3.r = 0 # c3.g = 0 # c3.b = 255 # c3.a = 255 # eq_(c1, c2) # eq_(c1, c3) # c1 = mapnik.Color(0, 64, 128) # c2 = mapnik.Color(0, 64, 128) # c3 = mapnik.Color(0, 0, 0) # c3.r = 0 # c3.g = 64 # c3.b = 128 # eq_(c1, c2) # eq_(c1, c3) # c1 = mapnik.Color(0, 64, 128, 192) # c2 = mapnik.Color(0, 64, 128, 192) # c3 = mapnik.Color(0, 0, 0, 255) # c3.r = 0 # c3.g = 64 # c3.b = 128 # c3.a = 192 # eq_(c1, c2) # eq_(c1, c3) # c1 = mapnik.Color('rgb(50%,50%,50%)') # c2 = mapnik.Color(128, 128, 128, 255) # c3 = mapnik.Color('#808080') # c4 = mapnik.Color('gray') # eq_(c1, c2) # eq_(c1, c3) # eq_(c1, c4) # c1 = mapnik.Color('hsl(0, 100%, 50%)') # red # c2 = mapnik.Color('hsl(120, 100%, 50%)') # lime # c3 = mapnik.Color('hsla(240, 100%, 50%, 0.5)') # semi-transparent solid # blue # eq_(c1, mapnik.Color('red')) # eq_(c2, mapnik.Color('lime')) # eq_(c3, mapnik.Color(0,0,255,128)) # def test_rule_init(): # min_scale = 5 # max_scale = 10 # r = mapnik.Rule() # eq_(r.name, '') # eq_(r.min_scale, 0) # eq_(r.max_scale, float('inf')) # eq_(r.has_else(), False) # eq_(r.has_also(), False) # r = mapnik.Rule() # r.set_else(True) # eq_(r.has_else(), True) # eq_(r.has_also(), False) # r = mapnik.Rule() # r.set_also(True) # eq_(r.has_else(), False) # eq_(r.has_also(), True) # r = mapnik.Rule("Name") # eq_(r.name, 'Name') # eq_(r.min_scale, 0) # eq_(r.max_scale, float('inf')) # eq_(r.has_else(), False) # eq_(r.has_also(), False) # r = mapnik.Rule("Name") # eq_(r.name, 'Name') # eq_(r.min_scale, 0) # eq_(r.max_scale, float('inf')) # eq_(r.has_else(), False) # eq_(r.has_also(), False) # r = mapnik.Rule("Name", min_scale) # eq_(r.name, 'Name') # eq_(r.min_scale, min_scale) # eq_(r.max_scale, float('inf')) # eq_(r.has_else(), False) # eq_(r.has_also(), False) # r = mapnik.Rule("Name", min_scale, max_scale) # eq_(r.name, 'Name') # eq_(r.min_scale, min_scale) # eq_(r.max_scale, max_scale) # eq_(r.has_else(), False) # eq_(r.has_also(), False) # if __name__ == "__main__": # setup() # run_all(eval(x) for x in dir() if x.startswith("test_"))