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 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 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_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 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 createIntersectionStyle(): style = mapnik.Style() rule = mapnik.Rule() point_symbolizer = mapnik.MarkersSymbolizer() point_symbolizer.allow_overlap = True point_symbolizer.opacity = 0.5 rule.symbols.append(point_symbolizer) style.rules.append(rule) return style
def point(color=None, stroke=None): symbolizer = mapnik.MarkersSymbolizer() symbolizer.transform = 'scale(0.3, 0.3)' if color is not None: symbolizer.fill = color if stroke is not None: symbolizer.stroke = stroke symbolizer.allow_overlap = True return symbolizer
def icon(file, transform=None, color=None, allowOverlap=False): symbolizer = mapnik.MarkersSymbolizer() symbolizer.filename = file symbolizer.allow_overlap = allowOverlap if color is not None: symbolizer.fill = color if transform is not None: symbolizer.transform = transform return symbolizer
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 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_with_detector(): ds = mapnik.MemoryDatasource() context = mapnik.Context() geojson = '{ "type": "Feature", "geometry": { "type": "Point", "coordinates": [ 0, 0 ] } }' ds.add_feature(mapnik.Feature.from_geojson(geojson, context)) s = mapnik.Style() r = mapnik.Rule() lyr = mapnik.Layer('point') lyr.datasource = ds lyr.styles.append('point') symb = mapnik.MarkersSymbolizer() symb.allow_overlap = False r.symbols.append(symb) s.rules.append(r) m = mapnik.Map(256, 256) m.append_style('point', s) m.layers.append(lyr) m.zoom_to_box(mapnik.Box2d(-180, -85, 180, 85)) im = mapnik.Image(256, 256) mapnik.render(m, im) expected_file = './images/support/marker-in-center.png' actual_file = '/tmp/' + os.path.basename(expected_file) #im.save(expected_file,'png8') im.save(actual_file, 'png8') actual = mapnik.Image.open(expected_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)) # now render will a collision detector that should # block out the placement of this point detector = mapnik.LabelCollisionDetector(m) eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, m.width, m.height)) eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, 256.0, 256.0)) eq_(detector.boxes(), []) detector.insert(detector.extent()) eq_(detector.boxes(), [detector.extent()]) im2 = mapnik.Image(256, 256) mapnik.render_with_detector(m, im2, detector) expected_file_collision = './images/support/marker-in-center-not-placed.png' #im2.save(expected_file_collision,'png8') actual_file = '/tmp/' + os.path.basename(expected_file_collision) im2.save(actual_file, 'png8')
def test_render_to_grid_multiple_times(): # create map with two layers m = mapnik.Map(256,256) s = mapnik.Style() r = mapnik.Rule() sym = mapnik.MarkersSymbolizer() sym.allow_overlap = True r.symbols.append(sym) s.rules.append(r) m.append_style('points',s) # NOTE: we use a csv datasource here # because the memorydatasource fails silently for # queries requesting fields that do not exist in the datasource ds1 = mapnik.Datasource(**{"type":"csv","inline":''' wkt,Name "POINT (143.10 -38.60)",South East'''}) lyr1 = mapnik.Layer('One') lyr1.datasource = ds1 lyr1.styles.append('points') m.layers.append(lyr1) ds2 = mapnik.Datasource(**{"type":"csv","inline":''' wkt,Value "POINT (142.48 -38.60)",South West'''}) lyr2 = mapnik.Layer('Two') lyr2.datasource = ds2 lyr2.styles.append('points') m.layers.append(lyr2) 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) mapnik.render_layer(m,grid,layer=0,fields=['Name']) # should throw right here since Name will be a property now on the `grid` object # and it is not found on the second layer mapnik.render_layer(m,grid,layer=1,fields=['Value']) grid.encode()
def make_tmp_map(): m = mapnik.Map(512,512) m.background_color = mapnik.Color('steelblue') ds = mapnik.MemoryDatasource() context = mapnik.Context() context.push('Name') f = mapnik.Feature(context,1) f['Name'] = 'Hello' f.add_geometries_from_wkt('POINT (0 0)') ds.add_feature(f) s = mapnik.Style() r = mapnik.Rule() sym = mapnik.MarkersSymbolizer() sym.allow_overlap = True r.symbols.append(sym) s.rules.append(r) lyr = mapnik.Layer('Layer') lyr.datasource = ds lyr.styles.append('style') m.append_style('style',s) m.layers.append(lyr) return m
def __init__(self, id, config): self.id = id client = pymongo.MongoClient() self.db = client.tiles self.db.tiles.ensure_index([("id", pymongo.ASCENDING), ("xyz", pymongo.ASCENDING)]) buf = BytesIO() im = PIL.Image.new("RGBA", (256, 256)) im.save(buf, "png") self.blanksize = buf.__sizeof__() print "Blank size: %i" % (self.blanksize) self.db.blank.drop() self.db.blank.insert_one({"tile": Binary(buf.getvalue())}) self.datasource = mapnik.PostGIS( host=config.host, user=config.user, password=config.password, dbname="obis", table= "(select geom from explore.points where species_id = %s) points" % (self.id), geometry_field="geom", srid="4326", extent="%s, %s, %s, %s" % (-180, -90, 180, 90), connext_timeout=10) self.style = mapnik.Style() rule = mapnik.Rule() symbolizer = mapnik.MarkersSymbolizer() symbolizer.width = 5.0 symbolizer.stroke_width = 0.0 symbolizer.fill = mapnik.Color("#ff0000") symbolizer.opacity = 1.0 symbolizer.allow_overlap = mapnik.Expression("True") rule.symbols.append(symbolizer) self.style.rules.append(rule)
def test_markersymbolizer_init(): p = mapnik.MarkersSymbolizer() eq_(p.allow_overlap, False) eq_(p.opacity, 1) eq_(p.filename, '') eq_(p.marker_type, mapnik.marker_type.ARROW) eq_(p.placement, mapnik.marker_placement.LINE_PLACEMENT) eq_(p.fill, mapnik.Color(0, 0, 255)) eq_(p.ignore_placement, False) eq_(p.spacing, 100) eq_(p.max_error, 0.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 eq_(p.allow_overlap, True) eq_(p.opacity, 0.5)
tile_request_pat = r'/(?P<version>\d{1,2}\.\d{1,3}\.\d{1,3})/(?P<layername>[a-z]{1,64})/(?P<z>\d{1,10})/(?P<x>\d{1,10})/(?P<y>\d{1,10})\.(?P<extension>(?:png|jpg|gif))' # hackish way to grab style obj and avoid parsing XML each request... m = mapnik.Map(1, 1) mapnik.load_map(m, settings.MAPNIK_STYLESHEET) style = m.find_style('style') del m style2 = mapnik.Style() r = mapnik.Rule() icon = '/ebs/projects/oakland/OpenTreeMap/static/images/SanDiego/map_icons/v4/marker-sm.png' sym = mapnik.PointSymbolizer(mapnik.PathExpression(icon)) sym.transform = 'scale(0.4)' sym.allow_overlap = True sym.opacity = .5 x = mapnik.MarkersSymbolizer() x.width = mapnik.Expression("20") x.stroke_width = mapnik.Expression("20") x.allow_overlap = True x.fill = '#ff0' x.stroke = '#ccc' r.symbols.append(sym) style2.rules.append(r) srv = None if settings.CACHE_SEARCH_METHOD == 'mem': srv = Service( Memcached(), {}, # layers are dynamic )
def tileMapConfig(map_id): map_selected = BasquiMap.objects.get(pk=map_id) layersMapOptions = LayerMapOptions.objects.filter( basqui_map=map_selected).order_by('-position') layers_used = Shapefile.objects.filter( Q(layermapoptions__basqui_map=map_selected), Q(layermapoptions__style_visible=True) | Q(layermapoptions__label_visible=True)) mapXML = mapnik.Map( TILE_WIDTH, TILE_HEIGHT, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" ) mapXML.buffer_size = 128 if len(layers_used) > 0: query = """(SELECT shapefile_id, coalesce(geom_multipoint, geom_multilinestring, geom_multipolygon) as g %s FROM layers_feature WHERE shapefile_id IN (%s) AND (geom_multipoint && !bbox! OR geom_multilinestring && !bbox! OR geom_multipolygon && !bbox! ) ) as geom""" % (''.join([ ",attribute_value->'" + label.field.name + "' as " + str(label.field.name).lower() + "_" + str(label.pk) for x in layersMapOptions.filter(label_visible=True) for label in x.layerlabel_set.all() ]).replace(',None', ''), ','.join([str(x.pk) for x in layers_used])) #','.join(["attribute_value->'" + x.label.field.name +"'" if x.label is not None else 'None' for x in layersMapOptions ]).replace(',None',''), datasource = mapnik.PostGIS( host=dbSettings['HOST'], user=dbSettings['USER'], password=dbSettings['PASSWORD'], dbname=dbSettings['NAME'], port=dbSettings['PORT'], table=query, geometry_field='g', #extent_from_subquery=True, estimate_extent=False, srid=3857, extent='-20037508.34, -20037508.34, 20037508.34, 20037508.34', simplify_geometries=True, geometry_table='layers_feature') featureLayer = mapnik.Layer("tiled_layer") featureLayer.srs = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" featureLayer.datasource = datasource featureLayer.cache_features = True #defining the feature layer styles for layerMapOptions in layersMapOptions.filter(style_visible=True): layerStyles = layerMapOptions.layerstyle_set.all().order_by( '-position') layer = layerMapOptions.layer featureLayer.styles.append( str(layer.name) + '_Styles_' + str(layerMapOptions.pk)) layer_style = mapnik.Style() for layerStyle in layerStyles: style_rule = mapnik.Rule() if layerStyle.filter: style_rule.filter = mapnik.Filter( "[shapefile_id] = %s and (%s)" % (layer.pk, str(layerStyle.filter))) else: style_rule.filter = mapnik.Filter("[shapefile_id] = %s" % layer.pk) if layerStyle.minScale: style_rule.min_scale = layerStyle.minScale if layerStyle.maxScale: style_rule.max_scale = layerStyle.maxScale if layer.geom_type in ["Point", "MultiPoint"]: m = mapnik.MarkersSymbolizer() m.filename = os.path.abspath("../media/%s" % layerStyle.marker.svg) m.fill = mapnik.Color(str(layerStyle.fill)) m.fill_opacity = layerStyle.fill_opacity s = mapnik.Stroke() s.color = mapnik.Color(str(layerStyle.stroke_color)) s.width = layerStyle.stroke_width s.opacity = layerStyle.stroke_opacity m.stroke = s if layerStyle.transform: m.transform = str(layerStyle.transform) m.allow_overlap = layerStyle.allow_overlap m.spacing = layerStyle.spacing m.max_error = layerStyle.max_error #m.placement = mapnik.marker_placement(layerStyle.placement) #m.ignore_placement = layerStyle.ignore_placement style_rule.symbols.append(m) elif layer.geom_type in ["LineString", "MultiLineString"]: l = mapnik.LineSymbolizer() l.stroke.color = mapnik.Color(str(layerStyle.stroke_color)) l.stroke.width = layerStyle.stroke_width l.stroke.opacity = layerStyle.stroke_opacity l.stroke.line_join = mapnik.line_join( layerStyle.stroke_linejoin) l.stroke.line_cap = mapnik.line_cap( layerStyle.stroke_linecap) if layerStyle.dash_array: dash_array = [ tuple(float(i) for i in el.strip('()').split(',')) for el in layerStyle.dash_array.split('),(') ] for d in dash_array: l.stroke.add_dash(d[0], d[1]) l.stroke.gamma = layerStyle.gamma l.stroke.gamma_method = mapnik.gamma_method( layerStyle.gamma_method) l.smooth = layerStyle.smooth l.simplify_tolerance = layerStyle.simplify_tolerance l.offset = layerStyle.stroke_offset l.clip = layerStyle.clip l.rasterizer = mapnik.line_rasterizer( layerStyle.stroke_rasterizer) style_rule.symbols.append(l) elif layer.geom_type in ["Polygon", "MultiPolygon"]: p = mapnik.PolygonSymbolizer() p.fill = mapnik.Color(str(layerStyle.fill)) p.fill_opacity = layerStyle.fill_opacity p.clip = layerStyle.clip p.gamma = layerStyle.gamma p.gamme_method = mapnik.gamma_method( layerStyle.gamma_method) p.smooth = layerStyle.smooth p.simplify_tolerance = layerStyle.simplify_tolerance l = mapnik.LineSymbolizer() l.stroke.color = mapnik.Color(str(layerStyle.stroke_color)) l.stroke.opacity = layerStyle.stroke_opacity l.stroke.width = layerStyle.stroke_width if layerStyle.dash_array: dash_array = [ tuple(float(i) for i in el.strip('()').split(',')) for el in layerStyle.dash_array.split('),(') ] for d in dash_array: l.stroke.add_dash(d[0], d[1]) l.offset = layerStyle.stroke_offset l.clip = layerStyle.clip l.stroke.gamma = layerStyle.gamma l.smooth = layerStyle.smooth l.simplify_tolerance = layerStyle.simplify_tolerance style_rule.symbols.append(p) style_rule.symbols.append(l) layer_style.rules.append(style_rule) mapXML.append_style( str(layer.name) + '_Styles_' + str(layerMapOptions.pk), layer_style) #defining label styles for layerMapOptions in layersMapOptions.filter(label_visible=True): layerLabels = layerMapOptions.layerlabel_set.all().order_by( '-position') layer = layerMapOptions.layer featureLayer.styles.append( str(layer.name) + '_Label_' + str(layerMapOptions.pk)) label_style = mapnik.Style() for layerLabel in layerLabels: label_rule = mapnik.Rule() if layerLabel.filter: label_rule.filter = mapnik.Filter( "[shapefile_id] = %s and (%s)" % (layer.pk, str(layerLabel.filter))) else: label_rule.filter = mapnik.Filter("[shapefile_id] = %s" % layer.pk) if layerLabel.minScale: label_rule.min_scale = layerLabel.minScale if layerLabel.maxScale: label_rule.max_scale = layerLabel.maxScale label_column = '[%s_%s]' % (str( layerLabel.field).lower(), str(layerLabel.pk)) t = mapnik.TextSymbolizer(mapnik.Expression(label_column), str(layerLabel.face_name), layerLabel.size, mapnik.Color(str(layerLabel.fill))) t.halo_fill = mapnik.Color(str(layerLabel.halo_fill)) t.halo_radius = layerLabel.halo_radius t.halo_rasterizer = mapnik.halo_rasterizer( layerLabel.halo_rasterizer) t.opacity = layerLabel.opacity t.character_spacing = layerLabel.character_spacing t.line_spacing = layerLabel.line_spacing t.text_ratio = layerLabel.text_ratio t.text_transform = mapnik.text_transform( layerLabel.text_transform) t.clip = layerLabel.clip t.label_placement = mapnik.label_placement( layerLabel.label_placement) t.vertical_alignment = mapnik.vertical_alignment( layerLabel.vertical_alignment) t.horizontal_alignment = mapnik.horizontal_alignment( layerLabel.horizontal_alignment) t.justify_alignment = mapnik.justify_alignment( layerLabel.justify_alignment) t.displacement = (layerLabel.dx, layerLabel.dy) t.orientation = mapnik.Expression(str(layerLabel.orientation)) t.rotate_displacement = layerLabel.rotate_displacement t.label_position_tolerance = layerLabel.label_position_tolerance t.avoid_edges = layerLabel.avoid_edges t.minimum_padding = layerLabel.minimum_padding t.allow_overlap = layerLabel.allow_overlap t.minimum_distance = layerLabel.minimum_distance t.repeat_distance = mapnik.Expression( str(layerLabel.repeat_distance)) t.minimum_path_length = layerLabel.minimum_path_length t.maximum_angle_char_delta = layerLabel.maximum_angle_char_delta t.wrap_width = layerLabel.wrap_width if layerLabel.wrap_character: t.wrap_character = ord(layerLabel.wrap_character) t.wrap_before = layerLabel.wrap_before label_rule.symbols.append(t) label_style.rules.append(label_rule) mapXML.append_style( str(layer.name) + '_Label_' + str(layerMapOptions.pk), label_style) mapXML.layers.append(featureLayer) #saving the map mapnik xml mapnik_xml_path = "../tilestache/%s/maps/viewer/%s_%s.xml" % (str( map_selected.created_by.username), str( map_selected.name), str(map_selected.pk)) mapnik.save_map(mapXML, mapnik_xml_path)
def test_render_grid(): ds = mapnik.MemoryDatasource() context = mapnik.Context() context.push('Name') f = mapnik.Feature(context,1) f['Name'] = 'South East' f.add_geometries_from_wkt('POINT (143.10 -38.60)') ds.add_feature(f) f = mapnik.Feature(context,2) f['Name'] = 'South West' f.add_geometries_from_wkt('POINT (142.48 -38.60)') ds.add_feature(f) f = mapnik.Feature(context,3) f['Name'] = 'North West' f.add_geometries_from_wkt('POINT (142.48 -38.38)') ds.add_feature(f) f = mapnik.Feature(context,4) f['Name'] = 'North East' f.add_geometries_from_wkt('POINT (143.10 -38.38)') ds.add_feature(f) s = mapnik.Style() r = mapnik.Rule() symb = mapnik.MarkersSymbolizer() symb.width = 10 symb.height = 10 symb.allow_overlap = True r.symbols.append(symb) s.rules.append(r) lyr = mapnik.Layer('Places') lyr.datasource = 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)
pnt.style.iconstyle.icon.href = 'http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png' kml.save('/picmap/out/kml_geo.kml') width_in_px = 4000 height_in_px = width_in_px / 2 mapfile = '/picmap/map-assets/mapnik_style.xml' map_canvas = mapnik.Map(width_in_px, height_in_px) mapnik.load_map(map_canvas, mapfile) map_canvas.background = mapnik.Color('rgb(0,0,0,0)') # transparent # Create a symbolizer to draw the points style = mapnik.Style() rule = mapnik.Rule() point_symbolizer = mapnik.MarkersSymbolizer() point_symbolizer.allow_overlap = True point_symbolizer.opacity = 1.0 # semi-transparent rule.symbols.append(point_symbolizer) style.rules.append(rule) map_canvas.append_style('GPS_tracking_points', style) # Create a layer to hold the ponts layer = mapnik.Layer('GPS_tracking_points') layer.datasource = mapnik.Ogr(file="/picmap/out/kml_geo.kml", layer_by_index=0) layer.styles.append('GPS_tracking_points') map_canvas.layers.append(layer) # Save the map map_canvas.zoom_all()
#Membuat poligon area rsby = mapnik.Rule() polygon_sby = mapnik.PolygonSymbolizer(mapnik.Color(217, 235, 203)) rsby.symbols.append(polygon_sby) #membuat rule polygon indonesia #Menggambar garis tepi #line_sby = mapnik.LineSymbolizer() #line_sby = mapnik.LineSymbolizer(mapnik.Color('grey'),1) #line_sby.stroke_width = 2.0 #rsby.symbols.append(line_sby) #menerapkan garis tepi ke rule map #Poin wisata ssby_wisata = mapnik.Style() rsby_wisata = mapnik.Rule() poin_wisata = mapnik.MarkersSymbolizer() poin_wisata.filename = 'beach.png' poin_wisata.width = mapnik.Expression('20') poin_wisata.height = mapnik.Expression('20') poin_wisata.allow_overlap = True rsby_wisata.symbols.append(poin_wisata) #membuat rule poin_wisata label = mapnik.TextSymbolizer(mapnik.Expression('[Kecamatan]'), 'DejaVu Sans Book', 5, mapnik.Color('Red')) label.halo_radius = 1 label.avoid_edges = False rsby_wisata.symbols.append(label) #membuat rule label #Membuat Layer Tempat Wisata layer_wisata = mapnik.Layer('Wisata', '+init=epsg:4326') ds = mapnik.MemoryDatasource()