def test_render_grid(): """ test old method """ width,height = 256,256 m = create_grid_map(width,height) 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 render_legend(mapfile, tile_uri): m = mapnik.Map(1024, 2048) # Load style XML mapnik.load_map(m, mapfile, True) # Obtain <Map> projection prj = mapnik.Projection(m.srs) # Projects between tile pixel co-ordinates and LatLong (EPSG:4326) tileproj = GoogleProjection(20) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = prj.forward(mapnik.Coord(14.4503,50.0673)) c1 = prj.forward(mapnik.Coord(14.457,50.0678)) # Bounding box for the tile if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y) else: bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y) render_size_x = 1024 render_size_y = 1500 m.resize(render_size_x, render_size_y) m.zoom_to_box(bbox) m.buffer_size = 128 # Render image with default Agg renderer im = mapnik.Image(render_size_x, render_size_y) mapnik.render(m, im) im.save(tile_uri, 'png256') surface = cairo.SVGSurface('legend.svg', render_size_x, render_size_y) mapnik.render(m, surface) surface.finish()
def render(self, filename, tile_x, tile_y, zoom): """ Render a single tile to a given filename. """ print 'Rendering %s' % (filename) # Calculate pixel positions of bottom-left & top-right half_width = self.width / 2 half_height = self.height / 2 px0 = (tile_x * self.width, (tile_y + 1) * self.height) px1 = ((tile_x + 1) * self.width, tile_y * self.height) # Convert tile coords to LatLng ll0 = self.tile_projection.fromPixelToLL(px0, zoom) ll1 = self.tile_projection.fromPixelToLL(px1, zoom) # Convert LatLng to map coords c0 = self.map_projection.forward(mapnik2.Coord(ll0[0], ll0[1])) c1 = self.map_projection.forward(mapnik2.Coord(ll1[0], ll1[1])) # Create bounding box for the render bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y) self.mapnik_map.zoom_to_box(bbox) self.mapnik_map.buffer_size = self.buffer_size # Render image with default renderer image = mapnik2.Image(self.width, self.height) mapnik2.render(self.mapnik_map, image) image.save(filename, self.filetype)
def render_tile(self, tile_uri, x, y, z): # Calculate pixel positions of bottom-left & top-right p0 = (x * 256, (y + 1) * 256) p1 = ((x + 1) * 256, y * 256) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, z) l1 = self.tileproj.fromPixelToLL(p1, z) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1])) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) render_size = 256 self.m.resize(render_size, render_size) self.m.zoom_to_box(bbox) if (self.m.buffer_size < 128): self.m.buffer_size = 128 # Render image with default Agg renderer im = mapnik.Image(render_size, render_size) mapnik.render(self.m, im) im.save(tile_uri, 'png256')
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_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_wgs84_inverse_forward(): p = mapnik2.Projection('+init=epsg:4326') c = mapnik2.Coord(3.01331418311, 43.3333092669) e = mapnik2.Box2d(-122.54345245, 45.12312553, 68.2335581353, 48.231231233) # It appears that the y component changes very slightly, is this OK? # so we test for 'almost equal float values' assert_almost_equal(p.inverse(c).y, c.y) assert_almost_equal(p.inverse(c).x, c.x) assert_almost_equal(p.forward(c).y, c.y) assert_almost_equal(p.forward(c).x, c.x) assert_almost_equal(p.inverse(e).center().y, e.center().y) assert_almost_equal(p.inverse(e).center().x, e.center().x) assert_almost_equal(p.forward(e).center().y, e.center().y) assert_almost_equal(p.forward(e).center().x, e.center().x) assert_almost_equal(c.inverse(p).y, c.y) assert_almost_equal(c.inverse(p).x, c.x) assert_almost_equal(c.forward(p).y, c.y) assert_almost_equal(c.forward(p).x, c.x) assert_almost_equal(e.inverse(p).center().y, e.center().y) assert_almost_equal(e.inverse(p).center().x, e.center().x) assert_almost_equal(e.forward(p).center().y, e.center().y) assert_almost_equal(e.forward(p).center().x, e.center().x)
def render_location_with_variants(self, variants): # target projection #merc = mapnik.Projection('+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') data = [] for item in range(0,variants): if item == 0: teta = 0 zoom = 20 shift_lat = 0 shift_lon = 0 else: shift_lat = 0.1*self.size*(random.random()-random.random()) shift_lon = 0.1*self.size*(random.random()-random.random()) teta = 45 * (random.random()-random.random()) zoom = random.randint(17,21) layer = "complete" projec = mapnik.Projection('+proj=aeqd +ellps=WGS84 +lat_0=90 +lon_0='+str(teta)) # WGS lat/long source projection of centre longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') # make a new Map object for the given mapfile m = mapnik.Map(self.width, self.height) mapfile = "renderer/map_data/styles/bs_" + layer + ".xml" mapnik.load_map(m, mapfile) # ensure the target map projection is mercator m.srs = projec.params() # transform the centre point into the target coord sys centre = mapnik.Coord(self.lon+shift_lon, self.lat+shift_lat) transform = mapnik.ProjTransform(longlat, projec) merc_centre = transform.forward(centre) # 360/(2**zoom) degrees = 256 px # so in merc 1px = (20037508.34*2) / (256 * 2**zoom) # hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units dx = ((20037508.34*2*(self.width/2)))/(256*(2 ** (zoom))) minx = merc_centre.x - dx maxx = merc_centre.x + dx # grow the height bbox, as we only accurately set the width bbox m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT bounds = mapnik.Box2d(minx, merc_centre.y-10, maxx, merc_centre.y+10) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT m.zoom_to_box(bounds) # render the map image to a file # mapnik.render_to_file(m, output) #render the map to an image im = mapnik.Image(self.width,self.height) mapnik.render(m, im) img = im.tostring('png256') img = cv2.imdecode(np.fromstring(img, dtype=np.uint8), 1) img =np.asarray(img) data.append(img) data = np.stack(data) return data
def render_tile(self, tile_uri, x, y, z): # Calculate pixel positions of bottom-left & top-right p0 = (x * 256, (y + 1) * 256) p1 = ((x + 1) * 256, y * 256) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, z) l1 = self.tileproj.fromPixelToLL(p1, z) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1])) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) render_size = 256 self.m.resize(render_size, render_size) self.m.zoom_to_box(bbox) self.m.buffer_size = 128 # Render image with default Agg renderer im = mapnik.Image(render_size, render_size) mapnik.render(self.m, im) im.save(tile_uri, 'png256') grid_uri = tile_uri.replace('.png', '.grid.json') # new mapnik.Grid api, works like mapnik.Image # with the exception that you can only render one # layer to it with the mapnik.render_layer function # create grid as same size as map/image grid = mapnik.Grid(render_size, render_size) # render a layer to that grid array mapnik.render_layer(self.m, grid, layer=0, fields=['POP2005', 'NAME']) # then encode the grid array as utf, resample to 1/4 the size, and dump features grid_utf = grid.encode('utf', resolution=4, add_features=True) # below is the old grid api - will be removed soon, don't use #grid_utf = mapnik.render_grid(self.m,0,key='__id__',resolution=4,fields=['POP2005','NAME']) # client code uses jsonp, so fake by wrapping in grid() callback open(grid_uri, 'wb').write('grid(' + json.dumps(grid_utf) + ')')
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 render_tile(self, tile_uri, x, y, z): # Calculate pixel positions of bottom-left & top-right p0 = (x * TILES_SIZE, (y + 1) * TILES_SIZE) p1 = ((x + 1) * TILES_SIZE, y * TILES_SIZE) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, z) l1 = self.tileproj.fromPixelToLL(p1, z) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1])) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) render_size = TILES_SIZE self.m.resize(render_size, render_size) self.m.zoom_to_box(bbox) self.m.buffer_size = 128 if FORMAT == 'grid': grid = mapnik.Grid(render_size, render_size) # mapnik.render_layer(self.m, grid, layer=64, fields=['name']) for n, l in enumerate(self.m.layers): if l.name != 'admin-012345678': if 'name' in l.datasource.fields(): mapnik.render_layer(self.m, grid, layer=n, fields=['name']) utfgrid = grid.encode('utf', resolution=4) f = open(tile_uri + '.' + FILE_EXTENSION, 'w') f.write(json.dumps(utfgrid)) f.close() else: # Render image with default Agg renderer im = mapnik.Image(render_size, render_size) mapnik.render(self.m, im) im.save(tile_uri + '.' + FILE_EXTENSION, FORMAT)
def test_render_grid2(): """ test old against new""" width,height = 256,256 m = create_grid_map(width,height) 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)) # new method grid = mapnik2.Grid(m.width,m.height,key='Name') mapnik2.render_layer(m,grid,layer=0,fields=['Name']) utf1 = grid.encode('utf',resolution=4) eq_(utf1,grid_correct_new) # old method - to be removed utf2 = mapnik2.render_grid(m,0,key='Name',resolution=4,fields=['Name']) eq_(utf2,grid_correct) # for complex polygons these will not be true eq_(len(utf2['grid']),len(utf1['grid'])) eq_(len(utf2['keys']),len(utf1['keys'])) eq_(len(utf2['data']),len(utf1['data'])) # 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"}) eq_(resolve(utf5,25,46),{"Name": "North East"}) eq_(resolve(utf5,38,10),{"Name": "South West"}) eq_(resolve(utf5,38,46),{"Name": "South East"})
def render_tile(self, tile_uri, x, y, z): # Calculate pixel positions of bottom-left & top-right # start=time.time() # p0 = (x * TILESIZE, (y + 1) * TILESIZE) # p1 = ((x + 1) * TILESIZE, y * TILESIZE) # # # Convert to LatLong (EPSG:4326) # l0 = self.tileproj.fromPixelToLL(p0, z); # l1 = self.tileproj.fromPixelToLL(p1, z); # # # Convert to map projection (e.g. mercator co-ords EPSG:900913) # c0 = self.prj.forward(mapnik2.Coord(l0[0],l0[1])) # c1 = self.prj.forward(mapnik2.Coord(l1[0],l1[1])) l0y, l0x = num2deg(x, y + 1, z) l1y, l1x = num2deg(x + 1, y, z) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik2.Coord(l0x, l0y)) c1 = self.prj.forward(mapnik2.Coord(l1x, l1y)) # Bounding box for the tile if hasattr(mapnik2, 'mapnik_version') and mapnik2.mapnik_version() >= 800: bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik2.Envelope(c0.x, c0.y, c1.x, c1.y) render_size = TILESIZE self.m.resize(render_size, render_size) self.m.zoom_to_box(bbox) self.m.buffer_size = 128 # Render image with default Agg renderer im = mapnik2.Image(render_size, render_size) # print("%f"%(time.time()-start)) # start=time.time() mapnik2.render(self.m, im) # print("%f"%(time.time()-start)) # start=time.time() im.save(tile_uri, 'png256')
def generate_map_tile(self, m, filename, z, x, y): # Code taken from OSM generate_tiles.py proj = GoogleProjection() mprj = mapnik.Projection(m.srs) p0 = (x * 256, (y + 1) * 256) p1 = ((x + 1) * 256, y * 256) l0 = proj.fromPixelToLL(p0, z); l1 = proj.fromPixelToLL(p1, z); c0 = mprj.forward(mapnik.Coord(l0[0], l0[1])) c1 = mprj.forward(mapnik.Coord(l1[0], l1[1])) if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) m.resize(256, 256) m.zoom_to_box(bbox) im = mapnik.Image(256, 256) mapnik.render(m, im) im.save(str(filename), "png256")
def render_tile(self, zoom, x, y): t0 = time.time() tl = "(zoom=%s x=%s y=%s)" % (zoom, x, y) self.log("Rendering tile %s" % tl) # Convert tile index to LatLong (EPSG:4326) l0 = xy_to_ll(zoom, (x, y + 1)) l1 = xy_to_ll(zoom, (x + 1, y)) # Convert to map projection (e.g. mercator co-ords EPSG:900913) # and get tile's bounding box c0 = self.prj.forward(mapnik2.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik2.Coord(l1[0], l1[1])) bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y) # Render self.m.resize(TS, TS) self.m.zoom_to_box(bbox) self.m.buffer_size = 128 im = mapnik2.Image(TS, TS) mapnik2.render(self.m, im) data = im.tostring("png256") # Save to database tc = TileCache.objects.filter(map=self.map.id, zoom=zoom, x=x, y=y).first() if tc: tc.ready = True tc.last_updated = datetime.datetime.now() tc.data = data tc.save() else: TileCache(map=self.map.id, zoom=zoom, x=x, y=y, ready=True, last_updated=datetime.datetime.now(), data=data).save() self.log("Tile %s completed in %dms" % (tl, (time.time() - t0) * 1000))
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 render_location_with_zoom(self, zoom): # target projection merc = mapnik.Projection('+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') # WGS lat/long source projection of centrel longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') # make a new Map object for the given mapfile m = mapnik.Map(self.width, self.height) mapnik.load_map(m, self.mapfile) # ensure the target map projection is mercator m.srs = merc.params() # transform the centre point into the target coord sys centre = mapnik.Coord(self.lon, self.lat) transform = mapnik.ProjTransform(longlat, merc) merc_centre = transform.forward(centre) # 360/(2**zoom) degrees = 256 px # so in merc 1px = (20037508.34*2) / (256 * 2**zoom) # hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units dx = ((20037508.34*2*(self.width/2)))/(256*(2 ** (zoom))) minx = merc_centre.x - dx maxx = merc_centre.x + dx # grow the height bbox, as we only accurately set the width bbox m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT bounds = mapnik.Box2d(minx, merc_centre.y-10, maxx, merc_centre.y+10) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT m.zoom_to_box(bounds) # render the map image to a file # mapnik.render_to_file(m, output) #render the map to an image im = mapnik.Image(self.width,self.height) mapnik.render(m, im) img = im.tostring('png256') img = cv2.imdecode(np.fromstring(img, dtype=np.uint8), 1) img =np.asarray(img) window_name = "Location" cv2.imshow(window_name, img) cv2.waitKey(1)
def rendertiles(self, cpoint, data, item, label, lat, layer, lon, num_items, projec, zoom): # target projection #merc = mapnik.Projection('+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') merc = projec # WGS lat/long source projection of centre longlat = mapnik.Projection( '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') # make a new Map object for the given mapfile m = mapnik.Map(self.width, self.height) mapfile = "/map_data/styles/bs_" + layer + ".xml" mapnik.load_map(m, mapfile) # ensure the target map projection is mercator m.srs = merc.params() # transform the centre point into the target coord sys centre = mapnik.Coord(cpoint[0], cpoint[1]) transform = mapnik.ProjTransform(longlat, merc) merc_centre = transform.forward(centre) # 360/(2**zoom) degrees = 256 px # so in merc 1px = (20037508.34*2) / (256 * 2**zoom) # hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units dx = ((20037508.34 * 2 * (self.width / 2))) / (256 * (2**(zoom))) minx = merc_centre.x - dx maxx = merc_centre.x + dx # grow the height bbox, as we only accurately set the width bbox m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT bounds = mapnik.Box2d( minx, merc_centre.y - 10, maxx, merc_centre.y + 10 ) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT m.zoom_to_box(bounds) # render the map image to a file # mapnik.render_to_file(m, output) #render the map to an image im = mapnik.Image(self.width, self.height) mapnik.render(m, im) img = im.tostring('png256') data[(item, layer)] = img
def rpc_renderCoord(self, lat, lon, zoom): im = mapnik.Image(self.mapsize[0], self.mapsize[1]) 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 self.rendermap.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT merc_bbox = mapnik.Box2d(minx, merc_center.y - 1, maxx, merc_center.y + 1) self.rendermap.zoom_to_box(merc_bbox) mapnik.render(self.rendermap, im) Map = im.tostring('png') return (True, Map)
def render_map(self, lat, lon, angle=None, angle_offset=0, zoom=None, overwrite=False, img_width=None, img_height=None, zoom_to_layer=False, layer_padding=10): """Renders map with help of mapnik If maps_cache is used it is first checked if image already exists in cache. Image name is created with self._make_name which creates name from lat_lon rounded to 5 decimals and width height if they are provided. If image exists and overwrite is False image is returned as ImageClip. If overwrite is True image is deleted and image is rendered and also returned as ImageClip. Parameters --------- lat : float Latitude in WGS84 - center point of a map (around 46 in Europe) lon : float Longitude in WGS84 - center point of a map (around 15 in Europe) angle : float If we want to rotate map. It should show where up is. AKA bearing angle_offset : int How much offset is between camera and forward direction so that map is correctly oriented zoom : float Mapnik zoom from 0-19 (higher number higher zoom) If we want different zoom then what was set in constructor overwrite : bool If we are using map cache do we want to overwrite existing images img_width : int If we want different size of map then what was set in constructor img_height : int If we want different size of map then what was set in constructor zoom_to_layer: bool If true it shows whole gpx layer in a map. lat, lon, zoom, angle are ignored layer_padding: int How much padding to add between edges of layer and image Returns ------- moviepy.video.VideoClip.ImageClip, tuple Rendered image as clip, and tuple with x and y coordinate of center in pixel units. (Used to add point on current location) """ map_uri = None width = self.map_width if img_width is None else img_width height = self.map_height if img_height is None else img_height if zoom is None: if self.map_zoom is None: raise Exception("One of map_zoom or zoom needs to be set!") zoom = self.map_zoom if angle is None: # spherical mercator (most common target map projection of osm data imported with osm2pgsql) merc = self.mercator_projection else: #Map rotation https://gis.stackexchange.com/questions/183175/rotating-90-using-two-point-equidistant-projection-with-proj4 merc = mapnik.Projection( '+proj=aeqd +ellps=sphere +lat_0=90 +lon_0=-' + str(angle + angle_offset)) self._lazy_init_map() # ensure the target map projection is mercator self.m.srs = merc.params() centre = mapnik.Coord(lon, lat) transform = mapnik.ProjTransform(MapnikRenderer.longlat, merc) merc_centre = transform.forward(centre) if img_width is not None and img_height is not None: self.m.resize(width, height) if not zoom_to_layer: # 360/(2**zoom) degrees = 256 px # so in merc 1px = (20037508.34*2) / (256 * 2**zoom) # hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units dx = ((20037508.34 * 2 * (width / 2))) / (256 * (2**(zoom))) minx = merc_centre.x - dx maxx = merc_centre.x + dx # grow the height bbox, as we only accurately set the width bbox self.m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT bounds = mapnik.Box2d( minx, merc_centre.y - 10, maxx, merc_centre.y + 10 ) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT else: names = ["gpx"] ppmm = 90.7 / 25.4 self.m.aspect_fix_mode = mapnik.aspect_fix_mode.GROW_BBOX #Next for loop is from Zverik/Nik4 app #Calculate extent of given layers and bbox for layer in (l for l in self.m.layers if l.name in names): # it may as well be a GPX layer in WGS84 proj = mapnik.Projection(layer.srs) bbox = layer.envelope() \ .inverse(proj).forward(self.mercator_projection) tscale = min((bbox.maxx - bbox.minx) / max(width, 0.01), (bbox.maxy - bbox.miny) / max(height, 0.01)) bbox.pad(layer_padding * ppmm * tscale) bounds = bbox # Note: aspect_fix_mode is only available in Mapnik >= 0.6.0 self.m.zoom_to_box(bounds) center_pixel_coord = self.m.view_transform().forward(merc_centre) #print ("img_width: {} map_width:{} width:{}".format(img_width, self.map_width, width)) if self.maps_cache is not None: zoom_name = zoom if self.zoom_changeable else None fn = self._make_name(lat, lon, width, height, zoom_name, zoom_to_layer) #print ("Rendering " + fn) map_uri = os.path.join(self.maps_cache, "{}.png".format(fn)) #If we don't want to overwrite and file already exists skip map rendering if not overwrite and os.path.isfile(map_uri): return ImageClip(map_uri), (center_pixel_coord.x, center_pixel_coord.y) #If we want to overwrite and file exists we remove file if overwrite and os.path.isfile(map_uri): os.remove(map_uri) #start = time.perf_counter() if self.maps_cache is not None: mapnik.render_to_file(self.m, map_uri) map_data = map_uri else: #Renders map to image in memory saves it to buffer and reads in numpy im = mapnik.Image(self.m.width, self.m.height) mapnik.render(self.m, im) #im.save("/tmp/tmp.png", 'png256') #Saving image to bytes buffer needs to be nonpalletted image otherwise it needs #to be converted to RGB when reading in numpy anyways string_image = im.tostring('png32') buffer = BytesIO(string_image) #with open("/tmp/tmp1.png", "wb") as o: #o.write(buffer.getvalue()) pil_image = ImagePIL.open(buffer) #print (pil_image.format, pil_image.mode, pil_image.size, #pil_image.palette) map_data = np.asarray(pil_image) #map_data = "/tmp/tmp.png" if img_width is not None and img_height is not None: self.m.resize(self.map_width, self.map_height) #print ("render took %r s" % (time.perf_counter()-start,)) return ImageClip(map_data), (center_pixel_coord.x, center_pixel_coord.y)
def render_map(mapfile): #A4 #filename = 'export_A4' #render_size_x = 842 #render_size_y = 595 #A3 #filename = 'export_A3' #render_size_x = 1191 #render_size_y = 842 #A2 #filename = 'export_A2' #render_size_x = 1684 #render_size_y = 1191 #A1 #filename = 'export_A1' #render_size_x = 2384 #render_size_y = 1684 #A0 filename = 'export_A0' render_size_x = 3370 render_size_y = 2384 #A-1 #filename = 'export_A-1' #render_size_x = 4768 #render_size_y = 3370 #A-2 #filename = 'export_A-2' #render_size_x = 6740 #render_size_y = 4768 m = mapnik.Map(render_size_x, render_size_y) # Load style XML mapnik.load_map(m, mapfile, True) # Obtain <Map> projection prj = mapnik.Projection(m.srs) # Projects between tile pixel co-ordinates and LatLong (EPSG:4326) tileproj = GoogleProjection(20) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = prj.forward(mapnik.Coord(14.33, 50.05)) c1 = prj.forward(mapnik.Coord(14.53, 50.14)) #filename = filename + '_BIG' #c0 = prj.forward(mapnik.Coord(14.25,49.95)) #c1 = prj.forward(mapnik.Coord(14.68,50.16)) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) m.resize(render_size_x, render_size_y) m.zoom_to_box(bbox) m.buffer_size = 128 # Render image with default Agg renderer #im = mapnik.Image(render_size_x, render_size_y) #mapnik.render(m, im) #im.save('export.png', 'png256') #surface = cairo.PDFSurface(filename + '.pdf', render_size_x, render_size_y) #mapnik.render(m, surface) surface = cairo.PSSurface(filename + '.ps', render_size_x, render_size_y) surface.dsc_comment("%%Title: Cyklisticka mapa prahy") surface.dsc_comment("%%Copyright: CC-BY-SA") mapnik.render(m, surface) #surface = cairo.SVGSurface(filename + '.svg', render_size_x, render_size_y) #mapnik.render(m, surface) surface.finish()
def metadata_image(bboxes, mapfile): """Create a metadata image""" from json import dumps as tojson import mapnik2 as mapnik features = [] for bbox in bboxes: minx, miny, maxx, maxy = bbox # create the bounding box as a json string width, height = (maxx - minx, maxy - miny) min_dim = 0.0125 # minimum dimension for display as a rectangle (in degrees) if width < min_dim or height < min_dim: # it should be a point feature = { "type": "Feature", "geometry": { "type": "Point", "coordinates": [minx, miny] }, "properties": { "type": "point" } } width, height = (9, 9) else: feature = { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [[[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy], [minx, miny]]] }, "properties": { "type": "bbox" } } features.append(feature) json = tojson({ "type": "FeatureCollection", "features": features }) # instantiate the map m = mapnik.Map(250, 250) mapnik.load_map_from_string(m, mapfile) # set the datasource for the last layer to show the bounding box datasource = mapnik.Ogr(file=json, layer='OGRGeoJSON') m.layers[-1].datasource = datasource # create an image of the area of interest with a border border = 80.0 # percentage border dx = width * (border / 100) minx2 = minx - dx; maxx2 = maxx + dx dy = height * (border / 100) miny2 = miny - dy; maxy2 = maxy + dy # don't create a border larger than the globe's extent if minx2 < -180.0 or maxx2 > 180.0 or miny2 < -90.0 or maxy2 > 90.0: minx2 = minx; maxx2 = maxx; miny2 = miny; maxy2 = maxy bbox = mapnik.Envelope(mapnik.Coord(minx2, miny2), mapnik.Coord(maxx2, maxy2)) m.zoom_to_box(bbox) image = mapnik.Image(m.width, m.height) mapnik.render(m, image) return image
map_uri = "image.png" #--------------------------------------------------- # Change this to the bounding box you want # #ll = (10.95,63.85, 11.05, 63.9) #ll = (10,63,11,64) ll = (6.8, 46.8, 7.2, 47.2) #ll= (0,10,0,10) #--------------------------------------------------- z = 10 imgx = 200 * z imgy = 200 * z m = mapnik2.Map(imgx, imgy) mapnik2.load_map(m, mapfile) prj = mapnik2.Projection("+init=epsg:3857 +over") #prj = mapnik2.Projection("+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") c0 = prj.forward(mapnik2.Coord(ll[0], ll[1])) c1 = prj.forward(mapnik2.Coord(ll[2], ll[3])) bbox = mapnik2.Box2d(c0.x, c0.y, c1.x, c1.y) #bbox=mapnik2.Box2d(-626172.1357121642,0,0,626172.1357121639) print c0, c1 print bbox m.zoom_to_box(bbox) im = mapnik2.Image(imgx, imgy) mapnik2.render(m, im) view = im.view(0, 0, imgx, imgy) # x,y,width,height view.save(map_uri, 'png256')
elif o in ("-w", "--width"): width = int(a) elif o in ("-h", "--height"): height = int(a) elif o in ("-o", "--output"): output = a # make a new Map object for the given mapfile m = mapnik.Map(width, height) mapnik.load_map(m, mapfile) # ensure the target map projection is mercator m.srs = merc.params() # transform the centre point into the target coord sys centre = mapnik.Coord(centrex, centrey) transform = mapnik.ProjTransform(longlat, merc) merc_centre = transform.forward(centre) # 360/(2**zoom) degrees = 256 px # so in merc 1px = (20037508.34*2) / (256 * 2**zoom) # hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units dx = ((20037508.34 * 2 * (width / 2))) / (256 * (2**(zoom))) minx = merc_centre.x - dx maxx = merc_centre.x + dx # grow the height bbox, as we only accurately set the width bbox m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT bounds = mapnik.Box2d( minx, merc_centre.y - 10, maxx, merc_centre.y +
def render_metatile(self, metatile): z = metatile.z x = metatile.x y = metatile.y # TODO: move all this somewhere else # Calculate pixel positions of bottom-left & top-right p0 = (x * self.tile_size, (y + self.metatile_size) * self.tile_size) p1 = ((x + self.metatile_size) * self.tile_size, y * self.tile_size) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, z) l1 = self.tileproj.fromPixelToLL(p1, z) # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1])) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) self.m.resize(self.image_size, self.image_size) self.m.zoom_to_box(bbox) if self.m.buffer_size < 128: self.m.buffer_size = 128 # we must decide wether to render the subtiles/children of this tile render_children = {child: False for child in metatile.children()} if not self.opts.dry_run: # Render image with default Agg renderer start = time.perf_counter() im = mapnik.Image(self.image_size, self.image_size) try: mapnik.render(self.m, im) except RuntimeError as e: exception("%r: %s", metatile, e) else: mid = time.perf_counter() # save the image, splitting it in the right amount of tiles for tile in metatile.tiles: i, j = tile.meta_index # TODO: Tile.meta_pixel_coords img = im.view(i * self.tile_size, j * self.tile_size, self.tile_size, self.tile_size) tile.data = img.tostring('png256') # TODO: move to Tile is_empty = map_utils.is_empty(tile.data) if not is_empty or self.opts.empty == 'write': self.backend.store(tile) # at least something to render. note that if we're # rendering only one tile (either metatile_size == 1 # or z == 0), i, j can only be == 0. this matches # the situation further down render_children[metatile.child(tile)] = True else: if self.opts.empty == 'skip': # empty tile, skip debug("%r: empty" % tile) continue # TODO: else? self.backend.commit() end = time.perf_counter() info("%r: %f, %f" % (metatile, mid - start, end - mid)) else: # simulate some work time.sleep(randint(0, 30) / 10) for child in metatile.children(): if random() <= 0.75 or 2**metatile.z < self.opts.metatile_size: render_children[child] = True return render_children
def render_metatile( self, metatile: map_utils.MetaTile) -> Dict[map_utils.Tile, bool]: # get LatLong (EPSG:4326) l0 = metatile.coords[0] l1 = metatile.coords[1] # this is the only time where we convert manually into WebMerc # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1])) # Bounding box for the tile if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y) else: bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y) image_size = self.opts.tile_size * min(self.metatile_size, 2** metatile.z) self.m.resize(image_size, image_size) self.m.zoom_to_box(bbox) if self.m.buffer_size < 128: self.m.buffer_size = 128 bail_out = True start = time.perf_counter() if not self.opts.dry_run: im = mapnik.Image(image_size, image_size) # Render image with default Agg renderer debug('[%s] rende...', self.name) # TODO: handle exception, send back into queue mapnik.render(self.m, im) debug('[%s] ...ring!', self.name) mid = time.perf_counter() # TODO: all this is on a single tile, not a metatile # converting to png256 is the fastest I have found so far: # python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring("png256")' # 100 loops, best of 3: 7.72 msec per loop # tostring() looks nice, but I can't rebuild a mapnik.Image from it :( # python3.6 -m timeit -s 'import mapnik; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = im.tostring()' # 100000 loops, best of 3: 13.8 usec per loop # python3.6 -m timeit -s 'import mapnik, bz2; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'c = bz2.BZ2Compressor(); c.compress(im.tostring()); data = c.flush()' # 10 loops, best of 3: 20.3 msec per loop # python3.6 -m timeit -s 'import mapnik, gzip; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' 'data = gzip.compress(im.tostring())' # 10 loops, best of 3: 27.7 msec per loop # python3.6 -s -m timeit -s 'import mapnik, lzma; im = mapnik.Image.fromstring(open("Attic/tmp/369.png", "br").read())' "c = lzma.LZMACompressor(); c.compress(im.tostring()); data = c.flush()" # 10 loops, best of 3: 92 msec per loop # TODO: # but bz2 compresses the best, 52714 png vs 49876 bzip vs 70828 gzip vs 53032 lzma if not self.opts.store_thread: # metatile will go in a non-marshaling queue, no need tostring() it metatile.im = im else: metatile.im = im.tostring('png256') end = time.perf_counter() else: debug('[%s] thumbtumbling', self.name) time.sleep(randint(0, 30) / 10) mid = time.perf_counter() end = time.perf_counter() metatile.render_time = mid - start metatile.serializing_time = end - mid bail_out = False debug("[%s] putting %r", self.name, metatile) self.output.put(metatile) debug("[%s] put! (%d)", self.name, self.output.qsize()) if not self.opts.store_thread and self.output.qsize() > 0: # NOTE: mypy complains here that Item "Process" of "Union[Process, StormBringer]" has no attribute "single_step" # the solutions are ugly, so I'm leaving it as that self.store_thread.single_step() return bail_out
def latlng_to_map(self, lat, lng): """Transforms given longlat Box2d or Coord to map projection.""" coord = mapnik2.Coord(lng, lat) merc_coord = self.lnglat_to_merc(coord) return self.merc_to_map(merc_coord)
def test_coord_multiplication(): c = mapnik2.Coord(100, 100) c *= 2 eq_(c.x, 200) eq_(c.y, 200)
def test_coord_init(): c = mapnik2.Coord(100, 100) eq_(c.x, 100) eq_(c.y, 100)
# This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # import mapnik2 mapfile = 'tutorial2.xml' map_output = '~/geodata/raster/world/hello_world_using_xml_config.png' map_output = 'hello_world_using_xml_config.png' # Instantiate a map object with given width, height and spatial reference system #m = mapnik.Map(600,300,"+proj=latlong +datum=WGS84") m = mapnik2.Map(600, 300) mapnik2.load_map(m, mapfile) bbox = mapnik2.Envelope(mapnik2.Coord(-180.0, -90.0), mapnik2.Coord(180.0, 90.0)) m.zoom_to_box(bbox) # Write the data to a png image called world.png in the base directory of your user mapnik2.render_to_file(m, map_output) # Exit the python interpreter exit()