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 singlePointStyle(self, name=None, scale=0.2): pointS = mapnik.Style() r = mapnik.Rule() if name is not None: #s=mapnik.PointSymbolizer(name,"png",size,size) s = mapnik.PointSymbolizer(name) else: s = mapnik.PointSymbolizer() s.allow_overlap = True s.transform = "scale(" + str(scale) + "," + str(scale) + ")" r.symbols.append(s) pointS.rules.append(r) return pointS
def render(self, shp_address=[WORK_DIR+'all_point.shp',WORK_DIR+'path_point.shp',\ WORK_DIR+'way.shp',WORK_DIR+'src_point.shp'], \ save_add = WORK_DIR+'output.png', graph_size = [1200,1200], bg = '#000000'): graph = mapnik.Map(graph_size[0], graph_size[1]) style = mapnik.Style() rule = mapnik.Rule() #polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('white')) #rule.symbols.append(polygon_symbolizer) point_symbolizer = mapnik.PointSymbolizer( mapnik.PathExpression(WORK_DIR + "fig\red_small.png")) rule.symbols.append(point_symbolizer) apoint_symbolizer = mapnik.PointSymbolizer( mapnik.PathExpression(WORK_DIR + "fig\blue_small.png")) #along the path rule.symbols.append(apoint_symbolizer) line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('#00FA9A'), 3) #the path rule.symbols.append(line_symbolizer) ypoint_symbolizer = mapnik.PointSymbolizer( mapnik.PathExpression(WORK_DIR + "fig\yellow_small.png")) # the src point rule.symbols.append(ypoint_symbolizer) style.rules.append(rule) graph.backgroud = mapnik.Color(bg) graph.append_style('default', style) #layer = ['polygon','line','point'] #address = [poly_add, line_add, node_add] layer = ['point', 'point', 'line', 'point'] address = [item for item in shp_address] for l1 in xrange(len(address)): ds = mapnik.Shapefile(file=address[l1]) lay = mapnik.Layer(layer[l1]) lay.datasource = ds lay.styles.append('default') graph.layers.append(lay) graph.zoom_all() mapnik.render_to_file(graph, save_add, 'png')
def polygon_map(): m = mapnik.Map(600, 300) # create a map with a given width and height in pixels # note: m.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' # the 'map.srs' is the target projection of the map and can be whatever you wish m.background = mapnik.Color('steelblue') # set background colour to 'steelblue'. s = mapnik.Style() # style object to hold rules r = mapnik.Rule() # rule object to hold symbolizers # to fill a polygon we create a PolygonSymbolizer polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#f2eff9') r.symbols.append(polygon_symbolizer) # add the symbolizer to the rule object # to add outlines to a polygon we create a LineSymbolizer sym = mapnik.PointSymbolizer() # args are file, type, height, width sym.allow_overlap = True sym.opacity = .5 r.symbols.append(sym) '''line_symbolizer = mapnik.LineSymbolizer() line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)') line_symbolizer.stroke_width = 0.1 r.symbols.append(line_symbolizer)'''# add the symbolizer to the rule object s.rules.append(r) # now add the rule to the style and we're done m.append_style('My Style', s) # Styles are given names only as they are applied to the map ds = mapnik.Shapefile(file='I:\Data\shashankdata\LSMDATASET\INVENTORY\INVENTORY.shp') layer = mapnik.Layer('Petrolling Party') # new layer called 'world' (we could name it anything) # note: layer.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' layer.datasource = ds layer.styles.append('My Style') m.layers.append(layer) # Write the data to a png image called world.png in the current directory mapnik.render_to_file(m, 'C:\Users\Hp\Desktop\pol\sha.png', 'png') # Exit the Python interpreter exit() # or ctrl-d
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 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_render_points(): if not mapnik.has_cairo(): return # create and populate point datasource (WGS84 lat-lon coordinates) ds = mapnik.MemoryDatasource() context = mapnik.Context() context.push('Name') f = mapnik.Feature(context, 1) f['Name'] = 'Westernmost Point' f.geometry = mapnik.Geometry.from_wkt('POINT (142.48 -38.38)') ds.add_feature(f) f = mapnik.Feature(context, 2) f['Name'] = 'Southernmost Point' f.geometry = mapnik.Geometry.from_wkt('POINT (143.10 -38.60)') ds.add_feature(f) # create layer/rule/style s = mapnik.Style() r = mapnik.Rule() symb = mapnik.PointSymbolizer() symb.allow_overlap = True r.symbols.append(symb) s.rules.append(r) lyr = mapnik.Layer('Places', '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') lyr.datasource = ds lyr.styles.append('places_labels') # latlon bounding box corners ul_lonlat = mapnik.Coord(142.30, -38.20) lr_lonlat = mapnik.Coord(143.40, -38.80) # render for different projections projs = { 'google': '+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 +wktext +no_defs +over', 'latlon': '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', 'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs', 'utm': '+proj=utm +zone=54 +datum=WGS84' } for projdescr in projs: m = mapnik.Map(1000, 500, projs[projdescr]) m.append_style('places_labels', s) m.layers.append(lyr) dest_proj = mapnik.Projection(projs[projdescr]) src_proj = mapnik.Projection('+init=epsg:4326') tr = mapnik.ProjTransform(src_proj, dest_proj) m.zoom_to_box(tr.forward(mapnik.Box2d(ul_lonlat, lr_lonlat))) # Render to SVG so that it can be checked how many points are there # with string comparison svg_file = os.path.join(tempfile.gettempdir(), 'mapnik-render-points-%s.svg' % projdescr) mapnik.render_to_file(m, svg_file) num_points_present = len(list(ds.all_features())) with open(svg_file, 'r') as f: svg = f.read() num_points_rendered = svg.count('<image ') eq_( num_points_present, num_points_rendered, "Not all points were rendered (%d instead of %d) at projection %s" % (num_points_rendered, num_points_present, projdescr))
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 render_tile(layer, z, x, y): """ Render the tile using mapnik. """ m = mapnik.Map(TILE_WIDTH, TILE_WIDTH) s = mapnik.Style() r = mapnik.Rule() point_sym = mapnik.PointSymbolizer() point_sym.allow_overlap = True point_sym.opacity = 10.0 point_sym.file = () r.symbols.append(point_sym) point = mapnik.PointSymbolizer() r.symbols.append(point) s.rules.append(r) m.append_style('Ruben', s) # Initialize layer from PostGIS table ds = mapnik.PostGIS(**POSTGIS_TABLE) layer = mapnik.Layer(LAYER_NAME) layer.datasource = ds layer.styles.append('Ruben') m.layers.append(layer) m.zoom_all() # ds = mapnik.Shapefile(file='C:\Users\ICS\Documents\kuliah\gis\gis mapnik\pantai indonesia\IND_PNT_polyline.shp') # layer = mapnik.Layer(LAYER_NAME) # layer.datasource = ds # layer.styles.append('My Style') # m.layers.append(layer) # m.zoom_all() renderer = TiledMapRenderer(m) im = renderer.render_tile(z, x, y) # im = mapnik.Image(TILE_WIDTH, TILE_WIDTH) # mapnik.render(m, im, 13, 0, 0) # im.save('tmp/bla.png') # mapnik.render_to_file(m,'aaa.png', 'png') return im.tostring('png'), 200, {'Content-type': 'image/png'}
def _render(themap, filename, format): m = themap.get_base_map().make_map() ctx = mapnik.Context() symbol_layers = {} for symbol in themap.get_symbols(): svgfile = '/tmp/%s.svg' % symbol.get_id() _generate_svg(svgfile, symbol) ps = mapnik.PointSymbolizer() ps.file = svgfile ps.allow_overlap = True ps.ignore_placement = True r = mapnik.Rule() r.symbols.append(ps) s = mapnik.Style() s.rules.append(r) m.append_style('symbol_' + symbol.get_id(), s) ix = 0 for marker in themap.get_markers(): f = mapnik.Feature.from_geojson( json.dumps({ "type": "Feature", "geometry": { "type": "Point", "coordinates": [ float(marker.get_longitude()), float(marker.get_latitude()) ] } }), ctx) ds = mapnik.MemoryDatasource() symbol_layers[symbol.get_id()] = ds l = mapnik.Layer('layer_%s' % ix) ix += 1 l.clear_label_cache = True l.datasource = ds l.styles.append('symbol_' + marker.get_symbol().get_id()) m.layers.append(l) ds.add_feature(f) mapnik.render_to_file(m, filename, format) box = None if themap.has_legend() and themap.has_symbols() and format == 'png': used_symbols = [ s for s in themap.get_symbols() if themap.is_symbol_used(s) ] box = _add_legend(filename, used_symbols) return box
def tms(z, x, y, service): # (4370311.220000, 4911352.860000) - (4403732.650000, 4958349.910000) # Extent: (4370177.610000, 4908530.650000) - (4411390.670000, 4958581.500000) bbox = dict(minx=4370177, miny=4908530, maxx=4411390, maxy=4958581) step = max(bbox['maxx'] - bbox['minx'], bbox['maxy'] - bbox['miny']) / 2**z extents = dict() extents['tms'] = (bbox['minx'] + x * step, bbox['miny'] + y * step, bbox['minx'] + (x + 1) * step, bbox['miny'] + (y + 1) * step) extents['xyz'] = (bbox['minx'] + x * step, bbox['maxy'] - (y + 1) * step, bbox['minx'] + (x + 1) * step, bbox['maxy'] - y * step) tile = dict(width=256, height=256) map = mapnik.Map(tile['width'], tile['height']) map.background = mapnik.Color('steelblue') mapnik.load_map(map, 'tile_server/style/styles.xml') layer = mapnik.Layer('point') ds = mapnik.PostGIS(host='127.0.0.1', dbname='isogd_sevastopol', user='******', password='******', table='tableapi.table_test_2_points_2') layer.datasource = ds pdb.set_trace() style = mapnik.Style() rule = mapnik.Rule() point_symbolizer = mapnik.PointSymbolizer() point_symbolizer.file = "/style/point_style.png" # pdb.set_trace() rule.symbols.append(point_symbolizer) style.rules.append(rule) map.append_style('My Style', style) map.zoom_all() mapnik.render_to_file(map, 'altay.png', 'png') box = mapnik.Box2d(*extents.get(service)) # map.zoom_all() map.zoom_to_box(box) mapnik.render_to_file(map, 'world.png', 'png') im = mapnik.Image(map.width, map.height) mapnik.render(map, im) output = im.tostring('png') # box = mapnik.Box2d(*extents.get(service)) # map.zoom_to_box(box) # mapnik.render_to_file(map, 'world.png', 'png') # im = mapnik.Image(map.width, map.height) # mapnik.render(map, im) # output = im.tostring('png') # # Передаём ответ клиенту return output
def mapnik_style(self): try: import mapnik except: import mapnik2 as mapnik point_style = mapnik.Style() r = mapnik.Rule() r.symbols.append(mapnik.PointSymbolizer()) point_style.rules.append(r) return point_style
def test_pointsymbolizer_init(): p = mapnik.PointSymbolizer() eq_(p.allow_overlap, False) eq_(p.opacity, 1) eq_(p.filename, '') eq_(p.ignore_placement, False) 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_introspect_symbolizers(): # create a symbolizer p = mapnik.PointSymbolizer() p.file = "../data/images/dummy.png" p.allow_overlap = True p.opacity = 0.5 # make sure the defaults # are what we think they are eq_(p.allow_overlap, True) eq_(p.opacity, 0.5) eq_(p.filename, '../data/images/dummy.png') # contruct objects to hold it r = mapnik.Rule() r.symbols.append(p) s = mapnik.Style() s.rules.append(r) m = mapnik.Map(0, 0) m.append_style('s', s) # try to figure out what is # in the map and make sure # style is there and the same s2 = m.find_style('s') rules = s2.rules eq_(len(rules), 1) r2 = rules[0] syms = r2.symbols eq_(len(syms), 1) # TODO here, we can do... sym = syms[0] p2 = sym.extract() assert isinstance(p2, mapnik.PointSymbolizer) eq_(p2.allow_overlap, True) eq_(p2.opacity, 0.5) eq_(p2.filename, '../data/images/dummy.png') # Make sure that extract() does not copy # the symbolizer object # Take new reference p3 = sym.extract() # Modify the object through the old reference p2.allow_overlap = False p2.opacity = 1.0 p2.file = '../data/images/xxx.png' eq_(p2.allow_overlap, p3.allow_overlap) eq_(p2.opacity, p3.opacity) eq_(p2.file, p3.file)
def test_pointsymbolizer_pickle(): raise Todo("point_symbolizer pickling currently disabled") p = mapnik.PointSymbolizer( mapnik.PathExpression("../data/images/dummy.png")) p2 = pickle.loads(pickle.dumps(p, pickle.HIGHEST_PROTOCOL)) # image type, width, and height only used in contructor... eq_(p.filename, p2.filename) eq_(p.allow_overlap, p2.allow_overlap) eq_(p.opacity, p2.opacity) eq_(p.ignore_placement, p2.ignore_placement) eq_(p.placement, p2.placement)
def test_introspect_symbolizers(): # create a symbolizer p = mapnik.PointSymbolizer( mapnik.PathExpression("../data/images/dummy.png")) p.allow_overlap = True p.opacity = 0.5 eq_(p.allow_overlap, True) eq_(p.opacity, 0.5) eq_(p.filename, '../data/images/dummy.png') # make sure the defaults # are what we think they are eq_(p.allow_overlap, True) eq_(p.opacity, 0.5) eq_(p.filename, '../data/images/dummy.png') # contruct objects to hold it r = mapnik.Rule() r.symbols.append(p) s = mapnik.Style() s.rules.append(r) m = mapnik.Map(0, 0) m.append_style('s', s) # try to figure out what is # in the map and make sure # style is there and the same s2 = m.find_style('s') rules = s2.rules eq_(len(rules), 1) r2 = rules[0] syms = r2.symbols eq_(len(syms), 1) ## TODO here, we can do... sym = syms[0] # this is hackish at best p2 = sym.symbol() assert isinstance(p2, mapnik.PointSymbolizer) eq_(p2.allow_overlap, True) eq_(p2.opacity, 0.5) eq_(p2.filename, '../data/images/dummy.png') ## but we need to be able to do: p2 = syms[0] # get the actual symbolizer, not the variant object # this will throw for now... assert isinstance(p2, mapnik.PointSymbolizer) eq_(p2.allow_overlap, True) eq_(p2.opacity, 0.5) eq_(p2.filename, '../data/images/dummy.png')
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_render_points(): if not mapnik.has_cairo(): return # create and populate point datasource (WGS84 lat-lon coordinates) ds = mapnik.MemoryDatasource() context = mapnik.Context() context.push('Name') f = mapnik.Feature(context, 1) f['Name'] = 'Westernmost Point' f.add_geometries_from_wkt('POINT (142.48 -38.38)') ds.add_feature(f) f = mapnik.Feature(context, 2) f['Name'] = 'Southernmost Point' f.add_geometries_from_wkt('POINT (143.10 -38.60)') ds.add_feature(f) # create layer/rule/style s = mapnik.Style() r = mapnik.Rule() symb = mapnik.PointSymbolizer() symb.allow_overlap = True r.symbols.append(symb) s.rules.append(r) lyr = mapnik.Layer('Places', '+proj=latlon +datum=WGS84') lyr.datasource = ds lyr.styles.append('places_labels') # latlon bounding box corners ul_lonlat = mapnik.Coord(142.30, -38.20) lr_lonlat = mapnik.Coord(143.40, -38.80) # render for different projections projs = { 'latlon': '+proj=latlon +datum=WGS84', 'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs', 'google': '+proj=merc +ellps=sphere +R=6378137 +a=6378137 +units=m', 'utm': '+proj=utm +zone=54 +datum=WGS84' } for projdescr in projs.iterkeys(): m = mapnik.Map(1000, 500, projs[projdescr]) m.append_style('places_labels', s) m.layers.append(lyr) p = mapnik.Projection(projs[projdescr]) m.zoom_to_box(p.forward(mapnik.Box2d(ul_lonlat, lr_lonlat))) # Render to SVG so that it can be checked how many points are there with string comparison svg_file = os.path.join(tempfile.gettempdir(), '%s.svg') mapnik.render_to_file(m, svg_file) num_points_present = len(ds.all_features()) svg = open(svg_file, 'r').read() num_points_rendered = svg.count('<image ') eq_( num_points_present, num_points_rendered, "Not all points were rendered (%d instead of %d) at projection %s" % (num_points_rendered, num_points_present, projdescr))
def default_style(): default_style = mapnik.Style() ps = mapnik.PolygonSymbolizer(mapnik.Color('#ffffff')) ps.fill_opacity = 0.5 ls = mapnik.LineSymbolizer(mapnik.Color('#555555'), 0.75) ls.stroke_opacity = 0.5 r = mapnik.Rule() r.symbols.append(ps) r.symbols.append(ls) r.symbols.append(mapnik.PointSymbolizer()) default_style.rules.append(r) return default_style
def test_point_symbolizer_grid(): width,height = 256,256 sym = mapnik.PointSymbolizer() sym.file = '../data/images/dummy.png' 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) mapnik.render_layer(m,grid,layer=0,fields=['Name']) utf1 = grid.encode() eq_(utf1,point_expected,show_grids('point-sym',utf1,point_expected))
def get_default_style(geometry_type): """ Ultra simple default style for quick setup or debugging. """ style, rule = mapnik.Style(), mapnik.Rule() gtype = geometry_type.lower() if 'poly' in gtype: rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('steelblue'))) rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color('steelblue'),.5)) elif 'line' in gtype: rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color('steelblue'),1.5)) else: point = mapnik.PointSymbolizer() point.allow_overlap = True rule.symbols.append(point) style.rules.append(rule) return style
def _get_map(self, normalized_args): """Return the Mapnik object (with hardcoded symbology/rule).""" # miss: # bgcolor # exceptions projection = parse_projection(normalized_args) # validate projection size = parse_size(normalized_args) mp = mapnik.Map(size.width, size.height, "+init=" + projection) # TODO: how do we manage style ? just have hardcoded # style list in a dir ? s = mapnik.Style() r = mapnik.Rule() r.symbols.append(mapnik.RasterSymbolizer()) s.rules.append(r) r.symbols.append(mapnik.PointSymbolizer()) s.rules.append(r) polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color("black") polygon_symbolizer.fill_opacity = 0 r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer() line_symbolizer.stroke = mapnik.Color("black") line_symbolizer.stroke_width = 1.0 r.symbols.append(line_symbolizer) s.rules.append(r) style_name = "My Style" mp.append_style(style_name, s) # TODO read the background set it # mp.background_color = 'steelblue' layer_names = parse_layers(normalized_args) for layer_name in layer_names: try: layer = geofile.load(layer_name) except FileNotFoundError as e: abort(404, e.strerror) mapnik_layer = layer.as_mapnik_layer() mapnik_layer.styles.append(style_name) mp.layers.append(mapnik_layer) return mp
def create_symbolizer(datasource): """ symbolizer fabric for various types of shape """ geom_type = datasource.geometry_type() if geom_type == DataGeometryType.Point: symbolizer = mapnik.PointSymbolizer() elif geom_type == DataGeometryType.Polygon: symbolizer = mapnik.PolygonSymbolizer() elif geom_type == DataGeometryType.LineString: symbolizer = mapnik.LineSymbolizer() elif geom_type == DataGeometryType.Collection: symbolizer = mapnik.LineSymbolizer() else: msg = 'Invalid geomerty type of object %s' % datasource raise GeometryTypeError(msg) return symbolizer
def __init__(self): BaseWMSFactory.__init__(self) name = "photos" title = "Geo-tagged photos" select = "photos" select = '''(SELECT kmeans, count(*), ST_Centroid(ST_Collect(point)) AS point FROM ( SELECT kmeans(ARRAY[ST_X(point), ST_Y(point)], 100) OVER (), point FROM photos WHERE point is not NULL ) AS ksub GROUP BY kmeans ORDER BY kmeans) as result ''' select = '''(SELECT kmeans, count(*), ST_ConvexHull(ST_Collect(point)) AS point FROM ( SELECT kmeans(ARRAY[ST_X(point), ST_Y(point)], 100) OVER (), point FROM photos WHERE point is not NULL ) AS ksub GROUP BY kmeans ORDER BY kmeans) as result ''' layer = mapnik.Layer(name,"+init=epsg:4326") layer.datasource = mapnik.PostGIS(host='localhost', user='******', password='******', dbname='remotesensing', table=select) layer.title = title layer.queryable = True layer.wms_srs = None style = mapnik.Style() rule = mapnik.Rule() #icon = "/web/eomf/dev/eomf/photos/circle.svg" sym = mapnik.PointSymbolizer() sym2 = mapnik.PolygonSymbolizer() #sym.filename = "/web/eomf/dev/eomf/photos/circle.svg" sym.allow_overlap = True sym.opacity = .5 rule.symbols.append(sym) rule.symbols.append(sym2) style.rules.append(rule) self.register_style(name,style) self.register_layer(layer, name, (name,)) self.finalize()
def style(self): """ Make mapnik point style """ symbol_manager = SymbolManager( ICON_ORIGINALS, os.path.join(settings.MEDIA_ROOT, 'generated_icons')) output_filename = symbol_manager.get_symbol_transformed( ICON_STYLE['icon'], **ICON_STYLE) output_filename_abs = os.path.join(settings.MEDIA_ROOT, 'generated_icons', output_filename) point_looks = mapnik.PointSymbolizer() point_looks.filename = output_filename_abs point_looks.allow_overlap = True layout_rule = mapnik.Rule() layout_rule.symbols.append(point_looks) point_style = mapnik.Style() point_style.rules.append(layout_rule) return point_style
def make_rules_for_input_combinations(self, possible_values, value_dict={}): """ Recursive function to loop all possible input combinations. For each input combination, calculate rule name and rule. possible_values: dict of fieldname as key and a dict of {value: None} value_dict: dict of all current values (starts empty) Return a dictionary with all rulename as key and rule as value. """ if possible_values: #not all possible values are put into value_dicts fieldname, fieldvalues = possible_values.items()[0] del possible_values[fieldname] rules = {} for fieldvalue in fieldvalues.keys(): new_rules = self.make_rules_for_input_combinations( possible_values, {fieldname: fieldvalue}) rules.update(new_rules) return rules else: #possible values are empty, all values are listed in value_dict rule_name = self.get_rule_name(value_dict) symbol_kwargs = self.get_output_properties(value_dict) symbol_out = symbol_kwargs['symbol'][0] + '.png' size_out_x, size_out_y = symbol_kwargs['size'] filename_abs = str( self.sm.get_symbol_transformed(symbol_out, **symbol_kwargs)) mapnik_rule = mapnik.Rule() ps = mapnik.PointSymbolizer() ps.file = filename_abs mapnik_rule.symbols.append(ps) mapnik_rule.filter = mapnik.Filter( str("[NAME] = '%s'" % (rule_name))) return {rule_name: mapnik_rule}
def render(self, **kwargs): m = mapnik.Map(kwargs['width'], kwargs['height'], '+init=epsg:' + str(kwargs['epsg'])) s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(str(kwargs['color']))) polygon_symbolizer.fill_opacity = kwargs['opacity'] r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'), 1.0) r.symbols.append(line_symbolizer) point_symbolizer = mapnik.PointSymbolizer() r.symbols.append(point_symbolizer) s.rules.append(r) m.append_style('My Style', s) ds = mapnik.Ogr(string=json.dumps(kwargs['geojson']), layer='OGRGeoJSON') layer = mapnik.Layer('wkt', '+init=epsg:' + str(kwargs['epsg'])) layer.datasource = ds layer.styles.append('My Style') m.layers.append(layer) extent = mapnik.Box2d(kwargs['bbox'][0], kwargs['bbox'][1], kwargs['bbox'][2], kwargs['bbox'][3]) m.zoom_to_box(extent) mapnik.render_to_file(m, str(kwargs['filename']), str(kwargs['filetype']))
def index(request): m = mapnik.Map(1240, 720) m.background = mapnik.Color('steelblue') s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#f2eff9') r.symbols.append(polygon_symbolizer) s.rules.append(r) highlight = mapnik.PointSymbolizer() highlight.file='mapnikApp/static/images/point.png' highlight.allow_overlap="yes" countryList = ['India', 'United Kingdom', 'United States', 'Canada'] for i in range(0, len(countryList)): countryName = mapnik.Rule() countryName.filter = mapnik.Expression("[name]='{}'".format(countryList[i])) countryName.symbols.append(highlight) s.rules.append(countryName) m.append_style('Borders', s) query = "(SELECT * FROM worldborders) AS data" ds = mapnik.PostGIS(dbname="temp", user="******", table=query) layer = mapnik.Layer("world") layer.datasource = ds layer.styles.append("Borders") m.layers.append(layer) m.zoom_all() mapnik.render_to_file(m, "mapnikApp/static/images/temp.png", "png") return render(request, "mapnikIndex.html")
def __add_measurements(self, layers, styles): "Docstring." measurements = SewerMeasurement.objects.filter( sewer__sewerage__pk=self.id ) style = mapnik.Style() for _, _, min_pct, max_pct, color in CLASSES: r, g, b, a = html_to_mapnik(color) icon = SYMBOL_MANAGER.get_symbol_transformed( RIOOL_ICON, color=(r, g, b, a) ) rule = mapnik.Rule() rule.filter = mapnik.Filter( str("[flooded_pct] >= %s and [flooded_pct] < %s" % (min_pct, max_pct)) ) symbol = mapnik.PointSymbolizer( os.path.join(GENERATED_ICONS, icon), "png", 16, 16 ) symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Style else rule. r, g, b, a = html_to_mapnik('00000') icon = SYMBOL_MANAGER.get_symbol_transformed( RIOOL_ICON, color=(r, g, b, a) ) rule = mapnik.Rule() rule.set_else(True) symbol = mapnik.PointSymbolizer( os.path.join(GENERATED_ICONS, icon), "png", 16, 16 ) symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Setup datasource. params = default_database_params() params['table'] = "({}) data".format(measurements.query) datasource = mapnik.PostGIS(**params) params = default_database_params() # Define layer. layer = mapnik.Layer('measurementLayer') layer.datasource = datasource layer.maxzoom = 35000 layer.styles.append('measurementStyle') layers.append(layer) styles['measurementStyle'] = style
def tileLayer(request, version, shapefile_id, zoom, x, y): try: if version != "1.0": raise Http404 try: shapefile = Shapefile.objects.get(id=shapefile_id, created_by=request.user) except Shapefile.DoesNotExist: raise Http404 zoom = int(zoom) x = int(x) y = int(y) if zoom < 0 or zoom > MAX_ZOOM_LEVEL: raise Http404 xExtent = _unitsPerPixel(zoom) yExtent = _unitsPerPixel(zoom) minLong = x * xExtent - 20037508.34 minLat = y * yExtent - 20037508.34 maxLong = minLong + xExtent maxLat = minLat + yExtent if (minLong < -20037508.34 or maxLong > 20037508.34 or minLat < -20037508.34 or maxLat > 20037508.34): raise Http404 #create de mapnik.map object map = 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" ) map.background = mapnik.Color("#f2f3f7") #defining the feature layer geometryField = utils.calcGeometryField(shapefile.geom_type) field = "'NOM'" field2 = "'CODE'" query = '(select ' + geometryField + ', attribute_value->' + field + ' as label, id_relat from "shapefile_feature" where' + ' shapefile_id in (' + str( shapefile.id) + ')) as geom' ## datasource = mapnik.SQLite(file='C:\mygeosite\sqlite3\sql3.db', ## table=query, ## srid=3857, ## geometry_field=geometryField) ## datasource = mapnik.PostGIS(user=dbSettings['USER'], ## password=dbSettings['PASSWORD'], ## dbname=dbSettings['NAME'], ## table=query, ## srid=3857, ## geometry_field=geometryField, ## simplify_geometries=True, ## geometry_table='"shapefile_feature"') feature = Feature.objects.filter(shapefile__id=shapefile_id).geojson() geoj = feature.geojson datasource = mapnik.Ogr(layer_by_index=0, string=geoj) ## featureLayer = mapnik.Layer("featureLayer") 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.styles.append("featureLayerStyle") #defining the feature layer styles rule = mapnik.Rule() if shapefile.geom_type in ["Point", "MultiPoint"]: rule.symbols.append(mapnik.PointSymbolizer()) elif shapefile.geom_type in ["LineString", "MultiLineString"]: rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) elif shapefile.geom_type in ["Polygon", "MultiPolygon"]: rule.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color("#f7edee"))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) ## label = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Book', 10, mapnik.Color('black')) ## label.halo_fill = mapnik.Color('white') ## label.halo_radius = 4 ## label.label_placement = mapnik.label_placement.INTERIOR_PLACEMENT ## label.allow_overlap = True ## label.avoid_edges = True ## rule.symbols.append(label) style = mapnik.Style() style.rules.append(rule) #add new feature to the map map.append_style("featureLayerStyle", style) map.layers.append(featureLayer) #rendering the map tile mapnik.save_map( map, "../tilestache/%s/%s.xml" % (str(request.user), str(shapefile.filename))) config = { "cache": { "name": "Test", "path": "../tilestache/%s" % (request.user), "umask": "0000", "dirs": "portable" }, "layers": { shapefile.filename: { "provider": { "name": "mapnik", "mapfile": "../tilestache/%s/%s.xml" % (request.user, shapefile.filename) }, "projection": "spherical mercator" } } } # like http://tile.openstreetmap.org/1/0/0.png #coord = ModestMaps.Core.Coordinate(y, x, zoom) path = "/%s/%s/%s/%s.png" % (shapefile.filename, zoom, x, y) config = TileStache.Config.buildConfiguration(config) #type, bytes = TileStache.getTile(config.layers[shapefile.filename], coord, 'png') type, bytes = TileStache.requestHandler(config, path) return HttpResponse(bytes, mimetype="image/png") except: traceback.print_exc() return HttpResponse("")