def create_grid_map(width,height): places_ds = mapnik2.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 = mapnik2.Style() r = mapnik2.Rule() #symb = mapnik2.PointSymbolizer() symb = mapnik2.MarkersSymbolizer() symb.allow_overlap = True r.symbols.append(symb) label = mapnik2.TextSymbolizer(mapnik2.Expression('[Name]'), 'DejaVu Sans Book', 10, mapnik2.Color('black') ) label.allow_overlap = True label.displacement = (0,-10) #r.symbols.append(label) s.rules.append(r) lyr = mapnik2.Layer('Places') lyr.datasource = places_ds lyr.styles.append('places_labels') m = mapnik2.Map(width,height) m.append_style('places_labels',s) m.layers.append(lyr) return m
def test_total_feature_count_json(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Ogr(file='../data/json/points.json', layer_by_index=0) features = lyr.datasource.all_features() num_feats = len(features) eq_(num_feats, 5)
def draw_gpx_track(self, gpx_file, gpx_style): """Adds layer which draws GPX Track Tracks layer from GPX file is drawn Notes ---- Since adding gpx_style to Mapnik XML doesn't work for some reason. Style for styling lines needs to already exists in Mapnik XML Parameters --------- gpx_file : str Full path to gpx file gpx_style : str Name of style layer for gpx file """ if gpx_file is not None and gpx_style is not None: # Create a layer to hold GPX points print("Adding GPX file") layer = mapnik.Layer("gpx") layer.datasource = mapnik.Ogr(file=gpx_file, layer='tracks') layer.styles.append(gpx_style) self.m.layers.append(layer)
def test_dataraster_query_point(): srs = '+init=epsg:32630' lyr = mapnik2.Layer('dataraster') lyr.datasource = mapnik2.Gdal( file='../data/raster/dataraster.tif', band=1, ) lyr.srs = srs _map = mapnik2.Map(256, 256, srs) _map.layers.append(lyr) # point inside raster extent with valid data x, y = 427417, 4477517 features = _map.query_point(0, x, y).features assert len(features) == 1 feat = features[0] center = feat.envelope().center() assert center.x == x and center.y == y, center value = feat['value'] assert value == 21.0, value # point outside raster extent features = _map.query_point(0, -427417, 4477517).features assert len(features) == 0 # point inside raster extent with nodata features = _map.query_point(0, 126850, 4596050).features assert len(features) == 0
def test_reading_json_from_string(): json = open('../data/json/points.json', 'r').read() lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Ogr(file=json, layer_by_index=0) features = lyr.datasource.all_features() num_feats = len(features) eq_(num_feats, 5)
def test_render_grid(): places_ds = mapnik2.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 = mapnik2.Style() r = mapnik2.Rule() #symb = mapnik2.PointSymbolizer() symb = mapnik2.MarkersSymbolizer() symb.allow_overlap = True r.symbols.append(symb) label = mapnik2.TextSymbolizer(mapnik2.Expression('[Name]'), 'DejaVu Sans Book', 10, mapnik2.Color('black')) label.allow_overlap = True label.displacement = (0, -10) #r.symbols.append(label) s.rules.append(r) lyr = mapnik2.Layer('Places') lyr.datasource = places_ds lyr.styles.append('places_labels') m = mapnik2.Map(256, 256) m.append_style('places_labels', s) m.layers.append(lyr) ul_lonlat = mapnik2.Coord(142.30, -38.20) lr_lonlat = mapnik2.Coord(143.40, -38.80) m.zoom_to_box(mapnik2.Box2d(ul_lonlat, lr_lonlat)) grid = mapnik2.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_feature_attributes(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Shapefile(file='../data/shp/poly.shp') features = lyr.datasource.all_features() feat = features[0] attrs = {'PRFEDEA': u'35043411', 'EAS_ID': 168, 'AREA': 215229.266} eq_(feat.attributes, attrs) eq_(lyr.datasource.fields(), ['AREA', 'EAS_ID', 'PRFEDEA']) eq_(lyr.datasource.field_types(), [float, int, str])
def test_feature_envelope(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Shapefile(file='../data/shp/poly.shp') features = lyr.datasource.all_features() for feat in features: env = feat.envelope() contains = lyr.envelope().contains(env) eq_(contains, True) intersects = lyr.envelope().contains(env) eq_(intersects, True)
def test_render_points(): # Test for effectivenes of ticket #402 (borderline points get lost on reprojection) raise Todo("See: http://trac.mapnik2.org/ticket/402") if not mapnik2.has_pycairo(): return # create and populate point datasource (WGS84 lat-lon coordinates) places_ds = mapnik2.PointDatasource() places_ds.add_point(142.48, -38.38, 'Name', 'Westernmost Point') # westernmost places_ds.add_point(143.10, -38.60, 'Name', 'Southernmost Point') # southernmost # create layer/rule/style s = mapnik2.Style() r = mapnik2.Rule() symb = mapnik2.PointSymbolizer() symb.allow_overlap = True r.symbols.append(symb) s.rules.append(r) lyr = mapnik2.Layer('Places', '+proj=latlon +datum=WGS84') lyr.datasource = places_ds lyr.styles.append('places_labels') # latlon bounding box corners ul_lonlat = mapnik2.Coord(142.30, -38.20) lr_lonlat = mapnik2.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' } from cairo import SVGSurface for projdescr in projs.iterkeys(): m = mapnik2.Map(1000, 500, projs[projdescr]) m.append_style('places_labels', s) m.layers.append(lyr) p = mapnik2.Projection(projs[projdescr]) m.zoom_to_box(p.forward(mapnik2.Box2d(ul_lonlat, lr_lonlat))) # Render to SVG so that it can be checked how many points are there with string comparison import StringIO svg_memory_file = StringIO.StringIO() surface = SVGSurface(svg_memory_file, m.width, m.height) mapnik2.render(m, surface) surface.flush() surface.finish() svg = svg_memory_file.getvalue() svg_memory_file.close() num_points_present = len(places_ds.all_features()) 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 test_layer_init(): l = mapnik2.Layer('test') eq_(l.name,'test') eq_(l.envelope(),mapnik2.Box2d()) eq_(l.clear_label_cache,False) eq_(l.cache_features,False) eq_(l.visible(),True) eq_(l.abstract,'') eq_(l.active,True) eq_(l.datasource,None) eq_(l.queryable,False) eq_(l.srs,'+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') eq_(l.title,'')
def generate_mapnik_map(self, user_id, global_id): m = mapnik.Map(256, 256) style = self.generate_mapnik_style(user_id, global_id) m.background = mapnik.Color("transparent") m.append_style("ZIP_CODES STYLE", style) m.srs = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" layer = mapnik.Layer('ZIP_CODES') layer.datasource = self.create_mapnik_datasource(user_id, global_id) layer.styles.append("ZIP_CODES STYLE") m.layers.append(layer) return m
def test_render_points(): if not mapnik2.has_cairo(): return # create and populate point datasource (WGS84 lat-lon coordinates) places_ds = mapnik2.PointDatasource() places_ds.add_point(142.48, -38.38, 'Name', 'Westernmost Point') # westernmost places_ds.add_point(143.10, -38.60, 'Name', 'Southernmost Point') # southernmost # create layer/rule/style s = mapnik2.Style() r = mapnik2.Rule() symb = mapnik2.PointSymbolizer() symb.allow_overlap = True r.symbols.append(symb) s.rules.append(r) lyr = mapnik2.Layer('Places', '+proj=latlon +datum=WGS84') lyr.datasource = places_ds lyr.styles.append('places_labels') # latlon bounding box corners ul_lonlat = mapnik2.Coord(142.30, -38.20) lr_lonlat = mapnik2.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 = mapnik2.Map(1000, 500, projs[projdescr]) m.append_style('places_labels', s) m.layers.append(lyr) p = mapnik2.Projection(projs[projdescr]) m.zoom_to_box(p.forward(mapnik2.Box2d(ul_lonlat, lr_lonlat))) # Render to SVG so that it can be checked how many points are there with string comparison svg_file = '/tmp/%s.svg' mapnik2.render_to_file(m, svg_file) num_points_present = len(places_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 rpc_renderCoordOld(self, lat, lon, zoom): """ Renders a map for the given coordinates. """ Map = None LandmassShapefile = 'cape/Interface/ne_110m_admin_0_countries.shp' im = mapnik.Image(self.mapsize[0], self.mapsize[1]) m = mapnik.Map(self.mapsize[0], self.mapsize[1]) m.background = mapnik.Color(self.backgroundColor) s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer( mapnik.Color(self.foregroundColor)) r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer( mapnik.Color('rgb(50%,50%,50%)'), 0.1) r.symbols.append(line_symbolizer) s.rules.append(r) m.append_style('My Style', s) ds = mapnik.Shapefile(file=LandmassShapefile) layer = mapnik.Layer('world') layer.datasource = ds layer.styles.append('My Style') m.layers.append(layer) center = mapnik.Coord(lat, lon) transform = mapnik.ProjTransform(self.longlat, self.merc) merc_center = transform.forward(center) dx = (20037508.34 * 2 * (self.mapsize[0] / 2)) / (256 * (2**(zoom))) minx = merc_center.x - dx maxx = merc_center.x + dx m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT merc_bbox = mapnik.Box2d(minx, merc_center.y - 1, maxx, merc_center.y + 1) m.zoom_to_box(merc_bbox) mapnik.render(m, im) Map = im.tostring('png') return (True, Map)
def test_dataraster_coloring(): srs = '+init=epsg:32630' lyr = mapnik2.Layer('dataraster') lyr.datasource = mapnik2.Gdal( file='../data/raster/dataraster.tif', band=1, ) lyr.srs = srs _map = mapnik2.Map(256, 256, srs) style = mapnik2.Style() rule = mapnik2.Rule() sym = mapnik2.RasterSymbolizer() # Assigning a colorizer to the RasterSymbolizer tells the later # that it should use it to colorize the raw data raster sym.colorizer = mapnik2.RasterColorizer(mapnik2.COLORIZER_DISCRETE, mapnik2.Color("transparent")) for value, color in [ (0, "#0044cc"), (10, "#00cc00"), (20, "#ffff00"), (30, "#ff7f00"), (40, "#ff0000"), (50, "#ff007f"), (60, "#ff00ff"), (70, "#cc00cc"), (80, "#990099"), (90, "#660066"), (200, "transparent"), ]: sym.colorizer.add_stop(value, mapnik2.Color(color)) rule.symbols.append(sym) style.rules.append(rule) _map.append_style('foo', style) lyr.styles.append('foo') _map.layers.append(lyr) _map.zoom_to_box(lyr.envelope()) im = mapnik2.Image(_map.width, _map.height) mapnik2.render(_map, im) # save a png somewhere so we can see it save_data('test_dataraster_coloring.png', im.tostring('png')) imdata = im.tostring() # we have some values in the [20,30) interval so check that they're colored assert contains_word('\xff\xff\x00\xff', imdata)
def create_map_and_append_symbolyzer(sym): srs = '+init=epsg:32630' lyr = mapnik2.Layer('arrows') lyr.datasource = mapnik2.Shapefile(file='../data/shp/arrows.shp', ) lyr.srs = srs _map = mapnik2.Map(256, 256, srs) style = mapnik2.Style() rule = mapnik2.Rule() rule.symbols.append(sym) # put a test symbolizer to see what is the azimuth being read ts = mapnik2.TextSymbolizer(mapnik2.Expression('[azimuth]'), "DejaVu Sans Book", 10, mapnik2.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(mapnik2.Box2d(0, 0, 8, 8)) return _map
def to_mapnik(self, mmap): """ """ mmap.srs = self.srs or mmap.srs mmap.bgcolor = str(self.bgcolor) or mmap.bgcolor ids = (i for i in xrange(1, 999999)) for layer in self.layers: for style in layer.styles: sty = mapnik.Style() for rule in style.rules: rul = mapnik.Rule('rule %d' % ids.next()) rul.filter = rule.filter and mapnik.Filter( rule.filter.text) or rul.filter rul.min_scale = rule.minscale and rule.minscale.value or rul.min_scale rul.max_scale = rule.maxscale and rule.maxscale.value or rul.max_scale for symbolizer in rule.symbolizers: if not hasattr(symbolizer, 'to_mapnik'): continue sym = symbolizer.to_mapnik() rul.symbols.append(sym) sty.rules.append(rul) mmap.append_style(style.name, sty) lay = mapnik.Layer(layer.name) lay.srs = layer.srs or lay.srs lay.minzoom = layer.minzoom or lay.minzoom lay.maxzoom = layer.maxzoom or lay.maxzoom for style in layer.styles: lay.styles.append(style.name) mmap.layers.append(lay)
def ogc_layer_to_mapnik(layer): idx = 0 m_layer = mapnik.Layer(str(getattr(layer, 'Name', None) or 'Layer')) styles = [] for user_style in layer.UserStyle: for feature_style in user_style.FeatureTypeStyle: m_sty = mapnik.Style() # TODO = Styles should have title,abstract, etc... sty_name = getattr(feature_style, 'Name', None) if not sty_name: sty_name = '%s %s' % (m_layer.name, str(idx)) sty_name = str(sty_name) for rule in feature_style.Rule: #print rule.get_childen() m_rule = ogc_rule_to_mapnik(rule) m_sty.rules.append(m_rule) m_layer.styles.append(sty_name) styles.append((sty_name, m_sty)) idx += 1 return m_layer, styles
def get(self): mapfile = os.path.join(DATA_PATH, 'hazard', 'flood.shp') #mapfile = os.path.join(DATA_PATH, 'impact', 'impact.json') filename = os.path.join(DATA_PATH, 'pdf', 'report_map.pdf') filename2 = os.path.join(DATA_PATH, 'pdf', 'report_map.png') map = mapnik2.Map(600, 400) map.background = mapnik2.Color('steelblue') s = mapnik2.Style() r = mapnik2.Rule() polygon_symbolizer = mapnik2.PolygonSymbolizer( mapnik2.Color('#f2eff9')) r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik2.LineSymbolizer( mapnik2.Color('rgb(50%,50%,50%)'), 0.1) r.symbols.append(line_symbolizer) s.rules.append(r) map.append_style('My Style', s) ds = mapnik2.Shapefile(file=mapfile) layer = mapnik2.Layer('world') layer.datasource = ds layer.styles.append('My Style') map.layers.append(layer) map.zoom_all() mapnik2.render_to_file(map, filename2, 'png') #bbox = mapnik.Envelope(-180.0,-90.0,180.0,90.0) #map.zoom_to_box(bbox) surface = cairo.PDFSurface(filename, map.width, map.height) mapnik2.render(map, surface) surface.finish() with open(filename) as data: pdf = data.read() data.close() self.set_header("Content-Type", "application/pdf") self.write(pdf)
def test_raster_with_alpha_blends_correctly_with_background(): WIDTH = 500 HEIGHT = 500 map = mapnik2.Map(WIDTH, HEIGHT) WHITE = mapnik2.Color(255, 255, 255) map.background = WHITE style = mapnik2.Style() rule = mapnik2.Rule() symbolizer = mapnik2.RasterSymbolizer() #XXX: This fixes it, see http://trac.mapnik.org/ticket/759#comment:3 # (and remove comment when this test passes) #symbolizer.scaling="bilinear_old" rule.symbols.append(symbolizer) style.rules.append(rule) map.append_style('raster_style', style) map_layer = mapnik2.Layer('test_layer') filepath = '../data/raster/white-alpha.png' map_layer.datasource = mapnik2.Gdal(file=filepath) map_layer.styles.append('raster_style') map.layers.append(map_layer) map.zoom_all() mim = mapnik2.Image(WIDTH, HEIGHT) mapnik2.render(map, mim) save_data('test_raster_with_alpha_blends_correctly_with_background.png', mim.tostring('png')) imdata = mim.tostring() # All white is expected assert contains_word('\xff\xff\xff\xff', imdata)
# add the polygon_symbolizer to the rule object r.symbols.append(polygon_symbolizer) r2.symbols.append(polygon_symbolizer2) # now add the rule(s) to the style s.rules.append(r) s2.rules.append(r2) # Styles are added to the map m.append_style('My Style', s) m.append_style('My Style2', s2) # Projection from PostGIS-Layer-Data lyr = mapnik2.Layer( 'Geometry from PostGIS', '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over' ) lyr2 = mapnik2.Layer( 'Geometry from PostGIS', '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over' ) # PostGIS-Connection + DB-Query lyr.datasource = mapnik2.PostGIS(host=hostname, user=db_user, password=db_pw, dbname=db_name, table=db_query) lyr2.datasource = mapnik2.PostGIS(host=hostname, user=db_user, password=db_pw,
# now add the rule(s) to the style and we're done s.rules.append(r) s2.rules.append(r2) s3.rules.append(r3) s4.rules.append(r4) # Styles are added to the map m.append_style('My Style', s) m.append_style('My Style2', s2) m.append_style('My Style3', s3) m.append_style('My Style4', s4) ### ### START Layer 1 ### lyr = mapnik2.Layer('Geometry from PostGIS') # note: layer.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' # database-query for overlay-data db_query = '''( SELECT geom FROM (SELECT geom, -- select latest edit in the whole database as timestamp of the dataset extract(days FROM(SELECT max(valid_from) FROM hist_plp) - valid_from) AS age FROM hist_polygon WHERE visible = 'true' AND (version = (SELECT max(version) FROM hist_polygon AS h WHERE h.id = hist_polygon.id AND
def mapnik_rendering(f_pct,f_vct,f_render): import mapnik2 as mapnik ref_pct = GR.geo_raster.open(f_pct) proj = ref_pct.projection tr = ref_pct.geo_transform width = ref_pct.width height = ref_pct.height size_p = tr[1] minx = tr[0] maxy = tr[3] miny = tr[3] - height * size_p maxx = tr[0] + width * size_p bbox = (minx, miny, maxx, maxy) #---- init _map = mapnik.Map(width,height) _map.background = mapnik.Color('black') #----==== raster style_gdal = mapnik.Style() # style object to hold rules rule_gdal = mapnik.Rule() # rule object to hold symbolizers symbol_gdal = mapnik.RasterSymbolizer() #symbol_gdal.opacity = 0.5 #$symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(255,255,255)) c = mapnik.RasterColorizer( mapnik.COLORIZER_LINEAR , mapnik.Color(0,0,0) ) c.epsilon = 0.001 c.add_stop(0) c.add_stop(900, mapnik.COLORIZER_LINEAR, mapnik.Color("#F3DDB4")) c.add_stop(1300, mapnik.COLORIZER_LINEAR, mapnik.Color("cyan")) c.add_stop(2000, mapnik.COLORIZER_LINEAR, mapnik.Color("white")) #c.get_color(2000) #c.stops[1].color #''' symbol_gdal.colorizer = c rule_gdal.symbols.append(symbol_gdal) style_gdal.rules.append(rule_gdal) _map.append_style("Raster Style", style_gdal) mlyr_gdal = mapnik.Layer('TM_images') mlyr_gdal.datasource = mapnik.Gdal(file=f_pct,band=1,bbox=bbox) #mlyr_gdal.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs ' mlyr_gdal.styles.append('Raster Style') _map.layers.append(mlyr_gdal) #''' #----==== shape style_vct = mapnik.Style() # style object to hold rules rule_vct = mapnik.Rule() # rule object to hold symbolizers #==== ==== add labels symbol_text = mapnik.TextSymbolizer(mapnik.Expression('[Code_uniq]'), 'DejaVu Sans Book', 20, mapnik.Color('black')) symbol_text.halo_fill = mapnik.Color('white') symbol_text.halo_radius = 1 symbol_text.avoid_edges = True #symbol_text.allow_overlap = False symbol_text.vertical_alignment = mapnik.vertical_alignment.TOP symbol_text.label_placement = mapnik.label_placement.POINT_PLACEMENT #LINE_PLACEMENT # is default rule_vct.symbols.append(symbol_text) #==== ==== 1.add polygon symbol_vct = mapnik.PolygonSymbolizer(mapnik.Color('#059BFF')) symbol_vct.opacity = 1#0.6 rule_vct.symbols.append(symbol_vct) # add the symbolizer to the rule object #==== ==== 2.add outlines line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('black'),0.3) rule_vct.symbols.append(line_symbolizer) # add the symbolizer to the rule object style_vct.rules.append(rule_vct) # now add the rule to the style and we're done _map.append_style('vector',style_vct) # Styles are given names only as they are applied to the map ds_shp = mapnik.Shapefile(file=f_vct) mlyr_shp = mapnik.Layer('lakes') mlyr_shp.datasource = ds_shp mlyr_shp.styles.append('vector') _map.layers.append(mlyr_shp) #''' _map.zoom_all() # Write the data to a png image called world.png the current directory mapnik.render_to_file(_map,f_render, 'png') print f_render
def mapnik_rendering(f_pct, f_vct, f_render): import mapnik2 as mapnik ref_pct = GR.geo_raster.open(f_pct) proj = ref_pct.projection tr = ref_pct.geo_transform width = ref_pct.width height = ref_pct.height size_p = tr[1] minx = tr[0] maxy = tr[3] miny = tr[3] - height * size_p maxx = tr[0] + width * size_p bbox = (minx, miny, maxx, maxy) #---- init _map = mapnik.Map(width, height) _map.background = mapnik.Color('black') #''' #----==== shape style_vct = mapnik.Style() # style object to hold rules rule_vct = mapnik.Rule() # rule object to hold symbolizers symbol_vct = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9')) symbol_vct.opacity = 0.8 rule_vct.symbols.append( symbol_vct) # add the symbolizer to the rule object line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'), 0.1) rule_vct.symbols.append( line_symbolizer) # add the symbolizer to the rule object style_vct.rules.append( rule_vct) # now add the rule to the style and we're done _map.append_style( 'vector', style_vct ) # Styles are given names only as they are applied to the map ds_shp = mapnik.Shapefile(file=f_vct) mlyr_shp = mapnik.Layer('lakes') mlyr_shp.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs ' mlyr_shp.datasource = ds_shp mlyr_shp.styles.append('vector') _map.layers.append(mlyr_shp) #''' #----==== raster style_gdal = mapnik.Style() # style object to hold rules rule_gdal = mapnik.Rule() # rule object to hold symbolizers symbol_gdal = mapnik.RasterSymbolizer() #symbol_gdal.mode = 'multiply' symbol_gdal.opacity = 0.5 #symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255)) c = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, mapnik.Color(255, 0, 0)) c.epsilon = 0.001 c.add_stop(0) c.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("red")) c.get_color(255) c.stops[1].color #''' symbol_gdal.colorizer = c rule_gdal.symbols.append(symbol_gdal) style_gdal.rules.append(rule_gdal) _map.append_style("Raster Style", style_gdal) mlyr_gdal = mapnik.Layer('TM_images') mlyr_gdal.datasource = mapnik.Gdal(file=f_pct, band=1, bbox=bbox) mlyr_gdal.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs ' mlyr_gdal.styles.append('Raster Style') _map.layers.append(mlyr_gdal) #==== style_gdal1 = mapnik.Style() # style object to hold rules rule_gdal1 = mapnik.Rule() # rule object to hold symbolizers symbol_gdal1 = mapnik.RasterSymbolizer() #symbol_gdal.mode = 'multiply' symbol_gdal1.opacity = 0.5 #symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255)) c1 = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, mapnik.Color(0, 255, 0)) c1.epsilon = 0.001 c1.add_stop(0) c1.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("green")) c1.get_color(255) c1.stops[1].color #''' symbol_gdal1.colorizer = c1 rule_gdal1.symbols.append(symbol_gdal1) style_gdal1.rules.append(rule_gdal1) _map.append_style("Raster Style2", style_gdal1) mlyr_gdal1 = mapnik.Layer('TM_images2') mlyr_gdal1.datasource = mapnik.Gdal(file=f_pct, band=2, bbox=bbox) mlyr_gdal1.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs ' mlyr_gdal1.styles.append('Raster Style2') _map.layers.append(mlyr_gdal1) #==== #==== style_gdal_b = mapnik.Style() # style object to hold rules rule_gdal_b = mapnik.Rule() # rule object to hold symbolizers symbol_gdal_b = mapnik.RasterSymbolizer() #symbol_gdal.mode = 'multiply' symbol_gdal_b.opacity = 0.5 #symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255)) c_b = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, mapnik.Color(0, 0, 255)) c_b.epsilon = 0.001 c_b.add_stop(0) c_b.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("blue")) c_b.get_color(255) c_b.stops[1].color #''' symbol_gdal_b.colorizer = c_b rule_gdal_b.symbols.append(symbol_gdal_b) style_gdal_b.rules.append(rule_gdal_b) _map.append_style("Raster Style3", style_gdal_b) mlyr_gdal_b = mapnik.Layer('TM_images3') mlyr_gdal_b.datasource = mapnik.Gdal(file=f_pct, band=3, bbox=bbox) mlyr_gdal_b.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs ' mlyr_gdal_b.styles.append('Raster Style3') _map.layers.append(mlyr_gdal_b) #==== _map.zoom_all() # Write the data to a png image called world.png the current directory mapnik.render_to_file(_map, f_render, 'png')
def test_field_listing(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Shapefile(file='../data/shp/poly.shp') fields = lyr.datasource.fields() eq_(fields, ['AREA', 'EAS_ID', 'PRFEDEA'])
def test_total_feature_count_shp(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Shapefile(file='../data/shp/poly.shp') features = lyr.datasource.all_features() num_feats = len(features) eq_(num_feats, 10)
#!/usr/bin/env python import mapnik2 as mapnik m = mapnik.Map(6000,3000,"+proj=latlong +datum=WGS84") m.background = mapnik.Color('steelblue') s = mapnik.Style() r=mapnik.Rule() r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))) r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1)) s.rules.append(r) m.append_style('My Style',s) lyr = mapnik.Layer('world',"+proj=latlong +datum=WGS84") lyr.datasource = mapnik.Shapefile(file='/opt/gdata/world_borders.shp') lyr.styles.append('My Style') m.layers.append(lyr) m.zoom_to_box(lyr.envelope()) mapnik.render_to_file(m,'world.png', 'png')
# Instanciate a layer. The parameters depend on the type of data: # shape: # type='shape' # file='/path/to/shape' # raster: # type='raster' # file='/path/to/raster' # postgis: # type='postgis' # host='127.0.0.1' # dbname='mydatabase' # user='******' # password='******' # table= TODO provpoly_lyr = mapnik2.Layer('Provinces') provpoly_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs" provpoly_lyr.datasource = mapnik2.Shapefile(file='../data/boundaries', encoding='latin1') # We then define a style for the layer. A layer can have one or many styles. # Styles are named, so they can be shared across different layers. # Multiple styles per layer behaves functionally like multiple layers. The # data is completely re-scanned for each style within one layer, and a style # will be drawn entirely "above" the previous one. Performance wise using # multiple styles in one layer is the same has having multiple layers. # The paradigm is useful mostly as a convenience. provpoly_style = mapnik2.Style() # A Style needs one or more rules. A rule will normally consist of a filter
def main(root,**options): m = mapnik.Map(1,1) idx = 0 layers = [] if hasattr(root,'NamedLayer'): layers.extend(root.NamedLayer) if hasattr(root,'UserLayer'): layers.extend(root.UserLayer) for layer in layers: lyr = mapnik.Layer(str(getattr(layer,'Name',None) or 'Layer')) datasource = options.get('datasource') if datasource and datasource.endswith('shp'): shp_dir = os.path.abspath(datasource).split('.shp')[0] name = datasource.split('.shp')[0] lyr.datasource = mapnik.Shapefile(file=shp_dir) if options.get('srid'): lyr.srs = '+init=epsg:%s' % options.get('srid') m.srs = lyr.srs else: srs = proj4_from_osr(shp_dir) if srs: lyr.srs = srs for user_style in layer.UserStyle: for feature_style in user_style.FeatureTypeStyle: m_sty = mapnik.Style() # TODO = Styles should have title,abstract, etc... sty_name = getattr(feature_style,'Name',None) if not sty_name: sty_name = '%s %s' % (lyr.name,str(idx)) sty_name = str(sty_name) for rule in feature_style.Rule: #print rule.get_childen() m_rule = mapnik.Rule(str(getattr(rule,'Name',''))) ogc_filter = rule.find("{%s}Filter" % rule.nsmap['ogc']) if ogc_filter is not None: # TODO - support ogc:And and oc:Or m_rule.filter = ogc_filter_to_mapnik(ogc_filter) else: if hasattr(rule,'ElseFilter'): m_rule.set_else(True) if hasattr(rule,'MaxScaleDenominator'): m_rule.max_scale = float(rule.MaxScaleDenominator) if hasattr(rule,'MinScaleDenominator'): m_rule.min_scale = float(rule.MinScaleDenominator) if hasattr(rule,'LineSymbolizer'): stroke = rule.LineSymbolizer.Stroke m_stroke = stroke_to_mapnik(stroke) m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke)) if hasattr(rule,'PolygonSymbolizer'): m_poly = mapnik.PolygonSymbolizer() if hasattr(rule.PolygonSymbolizer,'Fill'): fill = rule.PolygonSymbolizer.Fill for css in fill.CssParameter: if css.get('name') == 'fill': m_poly.fill = mapnik.Color(css.text) elif css.get('name') == 'fill-opacity': m_poly.opacity = float(css.text) else: raise Exception('unhanded: ' + css.get('name')) if hasattr(rule.PolygonSymbolizer,'Stroke'): stroke = rule.PolygonSymbolizer.Stroke m_stroke = stroke_to_mapnik(stroke) m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke)) m_rule.symbols.append(m_poly) if hasattr(rule,'PointSymbolizer'): #fill = rule.PolygonSymbolizer.Fill #m_point = point_to_mapnik(point) # TODO m_rule.symbols.append(mapnik.PointSymbolizer()) if hasattr(rule,'TextSymbolizer'): text = rule.TextSymbolizer name = text.Label.find("{%s}PropertyName" % rule.nsmap['ogc']) if not name and hasattr(text,'Label'): name = shlex.split(str(text.Label))[0] face_name = '[%s]' % text.Font face_name = 'DejaVu Sans Book' size = 10 for css in text.Font.CssParameter: if css.get('name') == 'font-family': face_name = css.text elif css.get('name') == 'font-size': size = int(float(css.text)) color = mapnik.Color('black') for css in text.Fill.CssParameter: if css.get('name') == 'fill': color = mapnik.Color(css.text) m_text = mapnik.TextSymbolizer(mapnik.Expression('['+str(name)+']'),str(face_name),int(size),color) if hasattr(text,'LabelPlacement'): if hasattr(text.LabelPlacement,'LinePlacement'): m_text.label_placement = mapnik.label_placement.LINE_PLACEMENT if hasattr(text,'Halo'): h = text.Halo if hasattr(h,'Radius'): m_text.halo_radius = float(h.Radius) if hasattr(h,'Fill'): for css in h.Fill.CssParameter: if css.get('name') == 'fill': m_text.halo_fill = mapnik.Color(css.text) m_rule.symbols.append(m_text) m_sty.rules.append(m_rule) lyr.styles.append(sty_name) m.append_style(sty_name,m_sty) idx+= 1 m.layers.append(lyr) if FIX_HEX: (handle, path) = tempfile.mkstemp(suffix='.xml', prefix='geotools2mapnik-') os.close(handle) open(path,'w').write(mapnik.save_map_to_string(m)) tree = objectify.parse(path) fix_colors(tree) print etree.tostring(tree)#,pretty_print=True) else: print mapnik.save_map_to_string(m)
# uses mapnik 2 import mapnik2 symbolizer = mapnik2.PolygonSymbolizer(mapnik2.Color("darkgrey")) rule = mapnik2.Rule() rule.symbols.append(symbolizer) style = mapnik2.Style() style.rules.append(rule) layer = mapnik2.Layer("mapLayer") layer.datasource = mapnik2.Shapefile( file="/data/82945364-10m-admin-0-countries.shp") layer.styles.append("mapStyle") map = mapnik2.Map(2400, 1200) map.background = mapnik2.Color("black") map.append_style("mapStyle", style) map.layers.append(layer) map.zoom_all() mapnik2.render_to_file(map, "map.png", "png")