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_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 renderTile(self, width, height, srs, coord): """ """ if self.mapnik is None: self.mapnik = mapnik.Map(0, 0) mapnik.load_map(self.mapnik, str(self.mapfile)) nw = self.layer.projection.coordinateLocation(coord) se = self.layer.projection.coordinateLocation(coord.right().down()) ul = self.mercator.locationProj(nw) lr = self.mercator.locationProj(se) self.mapnik.width = width self.mapnik.height = height self.mapnik.zoom_to_box(mapnik.Box2d(ul.x, ul.y, lr.x, lr.y)) # create grid as same size as map/image grid = mapnik.Grid(width, height) # render a layer to that grid array mapnik.render_layer(self.mapnik, grid, layer=self.layer_index, fields=self.fields) # then encode the grid array as utf, resample to 1/scale the size, and dump features grid_utf = grid.encode('utf', resolution=self.scale, features=True) if self.wrapper is None: return SaveableResponse(json.dumps(grid_utf)) else: return SaveableResponse(self.wrapper + '(' + json.dumps(grid_utf) + ')')
def get_one(self, tile: Tile) -> Optional[Tile]: bbox = self.tilegrid.extent(tile.tilecoord, self.buffer) bbox2d = mapnik.Box2d(bbox[0], bbox[1], bbox[2], bbox[3]) size = tile.tilecoord.n * self.tilegrid.tile_size + 2 * self.buffer self.mapnik.resize(size, size) self.mapnik.zoom_to_box(bbox2d) if self.output_format == "grid": grid = mapnik.Grid(self.tilegrid.tile_size, self.tilegrid.tile_size) for n, l in enumerate(self.mapnik.layers): if l.name in self.layers_fields: mapnik.render_layer(self.mapnik, grid, layer=n, fields=self.layers_fields[l.name]) encode = grid.encode("utf", resolution=self.resolution) if self.drop_empty_utfgrid and len(encode["data"].keys()) == 0: return None tile.data = dumps(encode).encode() else: # Render image with default Agg renderer im = mapnik.Image(size, size) mapnik.render(self.mapnik, im) tile.data = im.tostring(self.output_format) return tile
def rpc_renderArea(self, minlat, minlon, maxlat, maxlon): """ Renders a map for the given coordin """ Map = None LandmassShapefile = 'cape/Interface/ne_110m_admin_0_countries.shp' 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') # long/lat in degrees, aka ESPG:4326 and "WGS 84" longlat = mapnik.Projection( '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') # can also be constructed as: #longlat = mapnik.Projection('+init=epsg:4326') im = mapnik.Image(self.mapsize) m = self.rendermap m.srs = merc.params() bbox = mapnik.Box2d(minlat, minlon, maxlat, maxlon) transform = mapnik.ProjTransform(longlat, merc) merc_bbox = transform.forward(bbox) m.zoom_to_box(merc_bbox) mapnik.render(m, im) Map = im.tostring('png') return (True, Map)
def render_location(self): # spherical mercator (most common target map projection of osm data imported with osm2pgsql) 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') longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') mapfile = "renderer/map_data/styles/bs_complete.xml" bounds = (self.lon-self.size, self.lat-self.size, self.lon+self.size,self.lat+self.size) z = 1 imgx = 224 * z imgy = 224 * z m = mapnik.Map(imgx,imgy) mapnik.load_map(m,mapfile) m.srs = merc.params() if hasattr(mapnik,'Box2d'): bbox = mapnik.Box2d(*bounds) else: bbox = mapnik.Envelope(*bounds) transform = mapnik.ProjTransform(longlat,merc) merc_bbox = transform.forward(bbox) m.zoom_to_box(merc_bbox) #render the map to an image im = mapnik.Image(imgx,imgy) 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(0)
def rendertiles(self, bounds, data, item, label, lat, layer, lon, num_items, projec): z = 1 imgx = 128 * z imgy = 128 * z mapfile = "/map_data/styles/bs_" + layer + ".xml" m = mapnik.Map(imgx, imgy) mapnik.load_map(m, mapfile) # ensure the target map projection is mercator m.srs = projec.params() if hasattr(mapnik, 'Box2d'): bbox = mapnik.Box2d(*bounds) else: bbox = mapnik.Envelope(*bounds) transform = mapnik.ProjTransform(longlat, projec) merc_bbox = transform.forward(bbox) m.zoom_to_box(merc_bbox) # render the map to an image im = mapnik.Image(imgx, imgy) mapnik.render(m, im) img = im.tostring('png256') data[(item, layer)] = img
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 googleBoundsToBox2d(self, google_bounds): parts = google_bounds.split(",") strip_str = "() " min_lat = float(parts[0].strip(strip_str)) min_lng = float(parts[1].strip(strip_str)) max_lat = float(parts[2].strip(strip_str)) max_lng = float(parts[3].strip(strip_str)) return mapnik2.Box2d(min_lng, min_lat, max_lng, max_lat)
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_feature_hit_count(): # results in different results between shp and ogr! #bbox = (-14284551.8434, 2074195.1992, -7474929.8687, 8140237.7628) bbox = (1113194.91,4512803.085,2226389.82,6739192.905) query = mapnik2.Query(mapnik2.Box2d(*bbox)) ds1 = mapnik2.Ogr(file='../data/shp/world_merc.shp',layer_by_index=0) for fld in ds1.fields(): query.add_property_name(fld) ds2 = mapnik2.Shapefile(file='../data/shp/world_merc.shp') count1 = len(ds1.features(query).features) count2 = len(ds2.features(query).features) eq_(count1,count2,"Feature count differs between OGR driver (%s features) and Shapefile Driver (%s features) when querying the same bbox" % (count1,count2))
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 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 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_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_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 complexRun(image, stylesheet, extent, size): mapfile = stylesheet map_uri = image imgx = size[0] imgy = size[1] m = mapnik.Map(imgx, imgy) mapnik.load_map(m, mapfile) if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(extent[0], extent[2], extent[1], extent[3]) else: bbox = mapnik.Envelope(extent[0], extent[2], extent[1], extent[3]) m.zoom_to_box(bbox) im = mapnik.Image(imgx, imgy) mapnik.render(m, im) view = im.view(0, 0, imgx, imgy) # x,y,width,height view.save(map_uri, 'png')
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 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 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 renderTile(self, width, height, srs, coord): """ """ if self.mapnik is None: self.mapnik = mapnik.Map(0, 0) mapnik.load_map(self.mapnik, str(self.mapfile)) # buffer as fraction of tile size buffer = float(self.buffer) / 256 nw = self.layer.projection.coordinateLocation( coord.left(buffer).up(buffer)) se = self.layer.projection.coordinateLocation( coord.right(1 + buffer).down(1 + buffer)) ul = self.mercator.locationProj(nw) lr = self.mercator.locationProj(se) self.mapnik.width = width + 2 * self.buffer self.mapnik.height = height + 2 * self.buffer self.mapnik.zoom_to_box(mapnik.Box2d(ul.x, ul.y, lr.x, lr.y)) # create grid as same size as map/image grid = mapnik.Grid(width + 2 * self.buffer, height + 2 * self.buffer) # render a layer to that grid array mapnik.render_layer(self.mapnik, grid, layer=self.layer_index, fields=self.fields) # extract a gridview excluding the buffer grid_view = grid.view(self.buffer, self.buffer, width, height) # then encode the grid array as utf, resample to 1/scale the size, and dump features grid_utf = grid_view.encode('utf', resolution=self.scale, add_features=True) if self.wrapper is None: return SaveableResponse(json.dumps(grid_utf)) else: return SaveableResponse(self.wrapper + '(' + json.dumps(grid_utf) + ')')
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 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 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 rendertiles( bounds, item, label, lat, layers, lon, projec, writer): z = 1 imgx = 128 * z imgy = 128 * z for layer in layers: index = layers.index(layer) mapfile = "/map_data/styles/bs_" + layer + ".xml" m = mapnik.Map(imgx,imgy) mapnik.load_map(m,mapfile) # ensure the target map projection is mercator m.srs = projec.params() if hasattr(mapnik,'Box2d'): bbox = mapnik.Box2d(*bounds) else: bbox = mapnik.Envelope(*bounds) transform = mapnik.ProjTransform(longlat,projec) merc_bbox = transform.forward(bbox) m.zoom_to_box(merc_bbox) # render the map to an image im = mapnik.Image(imgx,imgy) mapnik.render(m, im) img = im.tostring('png256') if index == 0: data=[img] #data = np.expand_dims(data, 0) else: data.append(img) save_data(data, layers, item, label, lat, lon, writer)
def test_envelope_init(): e = mapnik2.Box2d(100, 100, 200, 200) assert_true(e.contains(100, 100)) assert_true(e.contains(100, 200)) assert_true(e.contains(200, 200)) assert_true(e.contains(200, 100)) assert_true(e.contains(e.center())) assert_false(e.contains(99.9, 99.9)) assert_false(e.contains(99.9, 200.1)) assert_false(e.contains(200.1, 200.1)) assert_false(e.contains(200.1, 99.9)) eq_(e.width(), 100) eq_(e.height(), 100) eq_(e.minx, 100) eq_(e.miny, 100) eq_(e.maxx, 200) eq_(e.maxy, 200) eq_(e[0],100) eq_(e[1],100) eq_(e[2],200) eq_(e[3],200) eq_(e[0],e[-4]) eq_(e[1],e[-3]) eq_(e[2],e[-2]) eq_(e[3],e[-1]) c = e.center() eq_(c.x, 150) eq_(c.y, 150)
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 test_envelope_pickle(): e1 = mapnik2.Box2d(-180, -90, 180, 90) e2 = mapnik2.Box2d(-120, 40, -110, 48) e1.clip(e2) eq_(e1, e2) # madagascar in merc e1 = mapnik2.Box2d(4772116.5490, -2744395.0631, 5765186.4203, -1609458.0673) e2 = mapnik2.Box2d(5124338.3753, -2240522.1727, 5207501.8621, -2130452.8520) e1.clip(e2) eq_(e1, e2) # nz in lon/lat e1 = mapnik2.Box2d(163.8062, -47.1897, 179.3628, -33.9069) e2 = mapnik2.Box2d(173.7378, -39.6395, 174.4849, -38.9252) e1.clip(e2) eq_(e1, e2)