Python mapnik.render_layer函数代码示例

    def test_render_layer_to_cairo_surface():
        ds = mapnik.MemoryDatasource()
        context = mapnik.Context()
        context.push('Name')
        f = mapnik.Feature(context, 1)
        f['Name'] = 'poly'
        f.geometry = mapnik.Geometry.from_wkt(
            'POLYGON ((1 1, -1 1, -1 -1, 1 -1, 1 1))')
        ds.add_feature(f)
        s = mapnik.Style()
        r = mapnik.Rule()
        symb = mapnik.PolygonSymbolizer()
        symb.fill = mapnik.Color('red')
        r.symbols.append(symb)
        s.rules.append(r)
        lyr = mapnik.Layer('poly')
        lyr.datasource = ds
        lyr.styles.append('poly')
        m = mapnik.Map(256, 256)
        m.append_style('poly', s)
        m.layers.append(lyr)
        m.zoom_all()

        surface = cairo.ImageSurface(
            cairo.FORMAT_ARGB32, m.width, m.height)
        mapnik.render_layer(m, surface, lyr)

        im = mapnik.Image.from_cairo(surface)

        eq_(im.is_solid(), True)
        c = im.get_pixel(0, 0, True)
        eq_(c.r, 255)
        eq_(c.g, 0)
        eq_(c.b, 0)
        eq_(c.a, 255)

def test_render_grid_new():
    """ test old against new"""
    width,height = 256,256
    m = create_grid_map(width,height)
    ul_lonlat = mapnik.Coord(142.30,-38.20)
    lr_lonlat = mapnik.Coord(143.40,-38.80)
    m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))

    # new method
    grid = mapnik.Grid(m.width,m.height,key='Name')
    mapnik.render_layer(m,grid,layer=0,fields=['Name'])
    utf1 = grid.encode('utf',resolution=4)
    eq_(utf1,grid_correct_new2,show_grids('new-markers',utf1,grid_correct_new2))

    # 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 test_line_rendering():
     ds = mapnik.MemoryDatasource()
     context = mapnik.Context()
     context.push('Name')
     pixel_key = 1
     f = mapnik.Feature(context,pixel_key)
     f['Name'] = str(pixel_key)
     f.add_geometries_from_wkt('LINESTRING (30 10, 10 30, 40 40)')
     ds.add_feature(f)
     s = mapnik.Style()
     r = mapnik.Rule()
     symb = mapnik.LineSymbolizer()
     r.symbols.append(symb)
     s.rules.append(r)
     lyr = mapnik.Layer('Places')
     lyr.datasource = ds
     lyr.styles.append('places_labels')
     width,height = 256,256
     m = mapnik.Map(width,height)
     m.append_style('places_labels',s)
     m.layers.append(lyr)
     m.zoom_all()
     #mapnik.render_to_file(m,'test.png')
     grid = mapnik.Grid(m.width,m.height,key='__id__')
     mapnik.render_layer(m,grid,layer=0,fields=['Name'])
     utf1 = grid.encode()
     eq_(utf1,line_expected,show_grids('line',utf1,line_expected))

def test_render_grid3():
    """ test using feature id"""
    width, height = 256, 256
    m = create_grid_map(width, height)
    ul_lonlat = mapnik.Coord(142.30, -38.20)
    lr_lonlat = mapnik.Coord(143.40, -38.80)
    m.zoom_to_box(mapnik.Box2d(ul_lonlat, lr_lonlat))

    grid = mapnik.Grid(m.width, m.height, key="__id__")
    mapnik.render_layer(m, grid, layer=0, fields=["__id__", "Name"])
    utf1 = grid.encode("utf", resolution=4)
    eq_(utf1["keys"], grid_feat_id["keys"])
    eq_(utf1["grid"], grid_feat_id["grid"])
    eq_(utf1["data"], grid_feat_id["data"])
    eq_(utf1, grid_feat_id)
    # 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, x, y, z, utf_grid):

        # 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

        if utf_grid is True:
            grid = mapnik.Grid(self.m.width,self.m.height)
            mapnik.render_layer(self.m, grid, layer=0, fields=['html_exp'])
            utfgrid = grid.encode('utf', resolution=4)
            return json.dumps(utfgrid);
        else:
            im = mapnik.Image(render_size, render_size)
            mapnik.render(self.m, im)
            return im.tostring('png');

    def renderTile(self, width, height, srs, coord):
        """
        """
        if self.mapnik is None:
            self.mapnik = get_mapnikMap(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 test_render_grid3():
     """ test using feature id"""
     width,height = 256,256
     sym = mapnik.MarkersSymbolizer()
     sym.width = mapnik.Expression('10')
     sym.height = mapnik.Expression('10')
     m = create_grid_map(width,height,sym)
     ul_lonlat = mapnik.Coord(142.30,-38.20)
     lr_lonlat = mapnik.Coord(143.40,-38.80)
     m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
 
     grid = mapnik.Grid(m.width,m.height,key='__id__')
     mapnik.render_layer(m,grid,layer=0,fields=['__id__','Name'])
     utf1 = grid.encode('utf',resolution=4)
     eq_(utf1,grid_feat_id3,show_grids('id-markers',utf1,grid_feat_id3))
     # check a full view is the same as a full image
     grid_view = grid.view(0,0,width,height)
     # for kicks check at full res too
     utf3 = grid.encode('utf',resolution=1)
     utf4 = grid_view.encode('utf',resolution=1)
     eq_(utf3['grid'],utf4['grid'])
     eq_(utf3['keys'],utf4['keys'])
     eq_(utf3['data'],utf4['data'])
 
     eq_(resolve(utf4,0,0),None)
 
     # resolve some center points in the
     # resampled view
     utf5 = grid_view.encode('utf',resolution=4)
     eq_(resolve(utf5,25,10),{"Name": "North West","__id__": 3})
     eq_(resolve(utf5,25,46),{"Name": "North East","__id__": 4})
     eq_(resolve(utf5,38,10),{"Name": "South West","__id__": 2})
     eq_(resolve(utf5,38,46),{"Name": "South East","__id__": 1})

    def 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 renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
        """
        """
        start_time = time()

        #
        # Mapnik can behave strangely when run in threads, so place a lock on the instance.
        #
        if global_mapnik_lock.acquire():
            try:
                if self.mapnik is None:
                    self.mapnik = get_mapnikMap(self.mapfile)
                    logging.debug('TileStache.Mapnik.GridProvider.renderArea() %.3f to load %s', time() - start_time, self.mapfile)

                self.mapnik.width = width
                self.mapnik.height = height
                self.mapnik.zoom_to_box(Box2d(xmin, ymin, xmax, ymax))

                if self.layer_id_key is not None:
                    grids = []

                    for (index, fields) in self.layers:
                        datasource = self.mapnik.layers[index].datasource
                        if isinstance(fields, list):
                            fields = [str(f) for f in fields]
                        else:
                            fields = datasource.fields()
                        grid = mapnik.Grid(width, height)
                        mapnik.render_layer(self.mapnik, grid, layer=index, fields=fields)
                        grid = grid.encode('utf', resolution=self.scale, features=True)

                        for key in grid['data']:
                            grid['data'][key][self.layer_id_key] = self.mapnik.layers[index].name

                        grids.append(grid)

                    # global_mapnik_lock.release()
                    outgrid = reduce(merge_grids, grids)

                else:
                    grid = mapnik.Grid(width, height)

                    for (index, fields) in self.layers:
                        datasource = self.mapnik.layers[index].datasource
                        fields = (type(fields) is list) and map(str, fields) or datasource.fields()

                        mapnik.render_layer(self.mapnik, grid, layer=index, fields=fields)

                    # global_mapnik_lock.release()
                    outgrid = grid.encode('utf', resolution=self.scale, features=True)
            except:
                self.mapnik = None
                raise
            finally:
                global_mapnik_lock.release()

        logging.debug('TileStache.Mapnik.GridProvider.renderArea() %dx%d at %d in %.3f from %s', width, height, self.scale, time() - start_time, self.mapfile)

        return SaveableResponse(outgrid, self.scale)

    def render(self, path, tile_x, tile_y, zoom):
        """
        Render a single tile to a given filename.
        """
        print 'Rendering %s' % (path)

        # 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(mapnik.Coord(ll0[0], ll0[1]))
        c1 = self.map_projection.forward(mapnik.Coord(ll1[0], ll1[1]))

        # Create bounding box for the render
        bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)

        self.mapnik_map.zoom_to_box(bbox)
        self.mapnik_map.buffer_size = self.buffer_size

        if self.filetype == 'svg':
            surface = cairo.SVGSurface(path, self.width, self.height)
            mapnik.render(self.mapnik_map, surface)
            surface.finish()
        else:
            image = mapnik.Image(self.width, self.height)
            mapnik.render(self.mapnik_map, image)
            image.save(path, self.filetype)

        if self.grid:
            if self.key:
                grid = mapnik.Grid(self.width, self.height)
            else:
                grid = mapnik.Grid(self.width, self.height, key=self.key)

            fields = []

            if self.fields:
                fields.extend(self.fields)

            mapnik.render_layer(self.mapnik_map,grid, layer=0, fields=fields)
            # then encode the grid array as utf, resample to 1/4 the size, and dump features
            # this comes from https://github.com/springmeyer/gridsforkids/blob/master/generate_tiles.py
            # with little consideration
            grid_utf = grid.encode('utf', resolution=4, features=True)

            # client code uses jsonp, so fake by wrapping in grid() callback
            base, ext = os.path.splitext(path)
            grid_filename = '%s.grid.json' % base
            print 'Rendering %s' % (grid_path)

            with open(grid_path, 'wb') as f:
                f.write('grid(' + json.dumps(grid_utf) + ')')

 def test_clearing_grid_data():
     g = mapnik.Grid(256, 256)
     utf = g.encode()
     # make sure it equals itself
     eq_(g.encode(), utf)
     m = make_map()
     mapnik.render_layer(m, g, layer=0, fields=['__id__', 'Name'])
     eq_(g.encode() != utf, True)
     # clear grid, should now match original
     g.clear()
     eq_(g.encode(), utf)

 def test_point_symbolizer_grid():
     width,height = 256,256
     sym = mapnik.PointSymbolizer()
     sym.file = '../data/images/dummy.png'
     m = create_grid_map(width,height,sym)
     ul_lonlat = mapnik.Coord(142.30,-38.20)
     lr_lonlat = mapnik.Coord(143.40,-38.80)
     m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
     grid = mapnik.Grid(m.width,m.height)
     mapnik.render_layer(m,grid,layer=0,fields=['Name'])
     utf1 = grid.encode()
     eq_(utf1,point_expected,show_grids('point-sym',utf1,point_expected))

    def render_grid(self, bbox, grid_fields, layer, width=None, height=None):
        """
        Render the specified grid with Mapnik
        """
        width = width or self.tilesize
        height = height or self.tilesize
        self._prepare_rendering(bbox, width=width, height=height)

        grid = mapnik.Grid(width, height)
        mapnik.render_layer(self._mapnik, grid, layer=layer, fields=grid_fields)
        grid = grid.encode()
        return json.dumps(grid)

    def _renderGridinfo(self,x,y,z,l0,l1,tile_uris):
        for i in range(int(self.tile_countX)):
            for j in range(int(self.tile_countY)):									
                pt0 = (x + self.tile_size*i, y + self.tile_size*(j+1))
                pt1 = (x + self.tile_size*(i+1), y + self.tile_size*j)

                # Convert to LatLong (EPSG:4326)
                lt0 = self.tileproj.fromPixelToLL(pt0, z);
                lt1 = self.tileproj.fromPixelToLL(pt1, z);

                # Convert to map projection (e.g. mercator co-ords EPSG:900913)
                ct0 = self.prj.forward(mapnik.Coord(lt0[0],lt0[1]))
                ct1 = self.prj.forward(mapnik.Coord(lt1[0],lt1[1]))
                
                if self.gridMap:
                    mi = 0
                    for country,_gridMap in self.gridMap.items():                        
                        if  self.countries[country].intersects(mapnik.Box2d(l0[0],l0[1],l1[0],l1[1])):
                            try:
                                _gridMap.zoom_to_box(mapnik.Box2d(ct0.x,ct0.y, ct1.x,ct1.y))
                                _gridMap.resize(int(self.tile_size), int(self.tile_size))
                                _gridMap.buffer_size = 0
                                grid = mapnik.Grid(int(self.tile_size), int(self.tile_size))
                                mapnik.render_layer(_gridMap, grid, layer = 1, fields=['symbol_name','wiki'])
                                mapnik.render_layer(_gridMap, grid, layer = 0, fields=['highway','grade','surface','smoothness','ref','int_ref','tracktype','name'])                
                                utfgrid = grid.encode('utf',resolution=4)                
                                for key1 in utfgrid['data']:
                                    for key2,val2 in utfgrid['data'][key1].items():
                                        if val2 in (None,'no',''):
                                            del utfgrid['data'][key1][key2]
                                gridname = tile_uris[i*self.tile_countY +j].replace(".jpg",".js")
                                f = codecs.open(gridname + '.tmp','w','utf-8')                
                                f.write(json.dumps(utfgrid, ensure_ascii = False))
                                f.close()
                                
                                if mi > 0:
                                    os.system('gzip -f %s' % (gridname + '.tmp'))
                                    if os.path.getsize(gridname + '.tmp.gz') > os.path.getsize(gridname+'.gz'):
                                        os.remove(gridname + '.gz')
                                        os.rename(gridname + '.tmp.gz',gridname+'.gz')
                                    else:
                                        os.remove(gridname + '.tmp.gz')
                                else:
                                    os.rename(gridname + '.tmp.gz',gridname+'.gz')
                            except Exception as E:
                                print E
                                
                                
                        mi += 1

    def __call__(self, layers, system):
        request = system['request']

        # get image width and height
        width = 256
        height = 256

        # get image bbox
        z = int(request.matchdict['z'])
        x = int(request.matchdict['x'])
        y = int(request.matchdict['y'])
        step = max/(2**(int(z) - 1))

        xmin = x*step-max
        ymin = max-y*step
        xmax = (x+1)*step-max
        ymax = max-(y+1)*step

        bbox = Box2d(xmin, ymax, xmax, ymin)

        m = Map(width, height)
        load_map(m, abspath_from_asset_spec('osmtm:views/map.xml'))

        for l in layers:
            m.layers.append(l)

        m.zoom_to_box(bbox)

        format = request.matchdict['format']
        if format == 'png':
            im = Image(width, height)
            render(m, im, 1, 1)

            request.response_content_type = 'image/png'
            return im.tostring('png')

        elif format == 'json':
            grid = Grid(width, height)
            render_layer(m, grid, layer=0, fields=['id'])
            utfgrid = grid.encode('utf', resolution=4)
            return json.dumps(utfgrid)