Beispiel #1
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_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()
Beispiel #3
0
 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 loop(self):
        
        self.m = mapnik.Map(256, 256)
        # Load style XML
        mapnik.load_map(self.m, self.mapfile, True)
        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = GoogleProjection(self.maxZoom+1)
                
        while True:
            #Fetch a tile from the queue and render it
            r = self.q.get()
            if (r == None):
                self.q.task_done()
                break
            else:
                (name, tile_uri, x, y, z) = r

            exists= ""
            if os.path.isfile(tile_uri):
                exists= "exists"
            else:
                self.render_tile(tile_uri, x, y, z)
            bytes=os.stat(tile_uri)[6]
            empty= ''
            if bytes == 103:
                empty = " Empty Tile "
            self.printLock.acquire()
            print name, ":", z, x, y, exists, empty
            self.printLock.release()
            self.q.task_done()
Beispiel #5
0
    def compare_map(in_map):

        mapnik2.load_map(map, in_map)

        (handle, test_map) = tempfile.mkstemp(suffix='.xml',
                                              prefix='mapnik-temp-map1-')
        os.close(handle)

        (handle, test_map2) = tempfile.mkstemp(suffix='.xml',
                                               prefix='mapnik-temp-map2-')
        os.close(handle)

        if os.path.exists(test_map):
            os.remove(test_map)

        mapnik2.save_map(map, test_map)
        new_map = mapnik2.Map(256, 256)

        mapnik2.load_map(new_map, test_map)
        open(test_map2, 'w').write(mapnik2.save_map_to_string(new_map))

        diff = ' diff %s %s' % (os.path.abspath(test_map),
                                os.path.abspath(test_map2))
        try:
            eq_(open(test_map).read(), open(test_map2).read())
        except AssertionError, e:
            raise AssertionError(
                'serialized map "%s" not the same after being reloaded, \ncompare with command:\n\n$%s'
                % (in_map, diff))
Beispiel #6
0
    def run(self):
        self.mapnik_map = mapnik2.Map(self.width, self.height)
        mapnik2.load_map(self.mapnik_map, self.config, True)

        self.map_projection = mapnik2.Projection(self.mapnik_map.srs)
        self.tile_projection = projections.GoogleProjection()

        while True:
            tile_parameters = None

            # Try to fetch a tile from any queue
            for tile_queue in self.tile_queues:
                try:
                    tile_parameters = tile_queue.get_nowait()
                    break
                except Queue.Empty:
                    pass

            # Couldn't get tile parameters from any queue--all done
            if not tile_parameters:
                return

            # Skip rendering existing tiles
            if self.skip_existing:
                filename = tile_parameters[0]

                if os.path.exists(filename):
                    print 'Skipping %s' % (filename)
                    tile_queue.task_done()

                    continue

            self.render(*tile_parameters)
            tile_queue.task_done()
Beispiel #7
0
def renderToPdf(envLL, filename, sizex, sizey):
    """Renders the specified Box2d and zoom level as a PDF"""
    basefilename = os.path.splitext(filename)[0]
    mergedpdf = None
    for mapname in MAPNIK_LAYERS:
        print 'Rendering', mapname
        # Render layer PDF.
        localfilename = basefilename + '_' + mapname + '.pdf';
        file = open(localfilename, 'wb')
        surface = cairo.PDFSurface(file.name, sizex, sizey) 
        envMerc = LLToMerc(envLL)
        map = mapnik.Map(sizex, sizey)
        mapnik.load_map(map, mapname + ".xml")
        map.zoom_to_box(envMerc)
        mapnik.render(map, surface)
        surface.finish()
        file.close()
        # Merge with master.
        if not mergedpdf:            
            mergedpdf = PdfFileWriter()
            localpdf = PdfFileReader(open(localfilename, "rb"))
            page = localpdf.getPage(0)
            mergedpdf.addPage(page)
        else:
            localpdf = PdfFileReader(open(localfilename, "rb"))
            page.mergePage(localpdf.getPage(0))
    output = open(filename, 'wb')
    mergedpdf.write(output)
    output.close()
    def loop(self):

        self.m = mapnik.Map(256, 256)
        # Load style XML
        mapnik.load_map(self.m, self.mapfile, True)
        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = spherical_mercator.SphericalMercator(self.maxZoom + 1)

        while True:
            # Fetch a tile from the queue and render it
            r = self.q.get()
            if (r == None):
                self.q.task_done()
                break
            else:
                (name, tile_uri, x, y, z) = r

            exists = ""
            if os.path.isfile(tile_uri):
                exists = "exists"
            else:
                self.render_tile(tile_uri, x, y, z)
            bytes = os.stat(tile_uri)[6]
            empty = ''
            if bytes == 103:
                empty = " Empty Tile "
            self.printLock.acquire()
            print(name, ":", z, x, y, exists, empty)
            self.printLock.release()
            self.q.task_done()
Beispiel #9
0
 def loadXML(self, xmlfile, strict=False):
     tmp_map = Map(0, 0)
     load_map(tmp_map, xmlfile, strict)
     for lyr in tmp_map.layers:
         style_count = len(lyr.styles)
         if style_count == 0:
             raise ServerConfigurationError(
                 "Cannot register Layer '%s' without a style" % lyr.name)
         elif style_count == 1:
             style_obj = tmp_map.find_style(lyr.styles[0])
             style_obj = copy_style(style_obj)
             style_name = lyr.styles[0]
             if style_name not in self.aggregatestyles.keys(
             ) and style_name not in self.styles.keys():
                 self.register_style(style_name, style_obj)
             self.register_layer(copy_layer(lyr),
                                 style_name,
                                 extrastyles=(style_name, ))
         elif style_count > 1:
             for style_name in lyr.styles:
                 style_obj = tmp_map.find_style(style_name)
                 style_obj = copy_style(style_obj)
                 if style_name not in self.aggregatestyles.keys(
                 ) and style_name not in self.styles.keys():
                     self.register_style(style_name, style_obj)
             aggregates = tuple([sty for sty in lyr.styles])
             aggregates_name = '%s_aggregates' % lyr.name
             self.register_aggregate_style(aggregates_name, aggregates)
             self.register_layer(copy_layer(lyr),
                                 aggregates_name,
                                 extrastyles=aggregates)
Beispiel #10
0
def renderToPdf(envLL, filename, sizex, sizey):
    """Renders the specified Box2d and zoom level as a PDF"""
    basefilename = os.path.splitext(filename)[0]
    mergedpdf = None
    for mapname in MAPNIK_LAYERS:
        print 'Rendering', mapname
        # Render layer PDF.
        localfilename = basefilename + '_' + mapname + '.pdf'
        file = open(localfilename, 'wb')
        surface = cairo.PDFSurface(file.name, sizex, sizey)
        envMerc = LLToMerc(envLL)
        map = mapnik.Map(sizex, sizey)
        mapnik.load_map(map, mapname + ".xml")
        map.zoom_to_box(envMerc)
        mapnik.render(map, surface)
        surface.finish()
        file.close()
        # Merge with master.
        if not mergedpdf:
            mergedpdf = PdfFileWriter()
            localpdf = PdfFileReader(open(localfilename, "rb"))
            page = localpdf.getPage(0)
            mergedpdf.addPage(page)
        else:
            localpdf = PdfFileReader(open(localfilename, "rb"))
            page.mergePage(localpdf.getPage(0))
    output = open(filename, 'wb')
    mergedpdf.write(output)
    output.close()
Beispiel #11
0
    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) + ")")
Beispiel #12
0
    def run(self):
        self.mapnik_map = mapnik2.Map(self.width, self.height)
        mapnik2.load_map(self.mapnik_map, self.config, True)

        self.map_projection = mapnik2.Projection(self.mapnik_map.srs)
        self.tile_projection = projections.GoogleProjection()  

        while True:
            tile_parameters = None

            # Try to fetch a tile from any queue
            for tile_queue in self.tile_queues:
                try:
                    tile_parameters = tile_queue.get_nowait()
                    break 
                except Queue.Empty:
                    pass

            # Couldn't get tile parameters from any queue--all done
            if not tile_parameters:
                return

            # Skip rendering existing tiles
            if self.skip_existing:
                filename = tile_parameters[0]

                if os.path.exists(filename):
                    print 'Skipping %s' % (filename)
                    tile_queue.task_done()

                    continue

            self.render(*tile_parameters)
            tile_queue.task_done()
Beispiel #13
0
    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) + ')')
Beispiel #14
0
    def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
        """
        """
        if self.mapnik is None:
            self.mapnik = mapnik.Map(0, 0)

            if exists(self.mapfile):
                mapnik.load_map(self.mapnik, str(self.mapfile))

            else:
                handle, filename = mkstemp()
                os.write(handle, urlopen(self.mapfile).read())
                os.close(handle)

                mapnik.load_map(self.mapnik, filename)
                os.unlink(filename)

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

        img = mapnik.Image(width, height)
        mapnik.render(self.mapnik, img)

        img = Image.fromstring('RGBA', (width, height), img.tostring())

        return img
Beispiel #15
0
    def loop(self, nb):
        self.m = mapnik.Map(TILES_SIZE, TILES_SIZE)
        # Load style XML
        mapnik.load_map(self.m, self.mapfile, True)
        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = GoogleProjection(self.maxZoom + 1)

        while True:
            #Fetch a tile from the queue and render it
            r = self.q.get()
            if (r == None):
                self.q.task_done()
                break
            else:
                (name, tile_uri, x, y, z) = r

            exists = ""
            if os.path.isfile(tile_uri + '.' + FILE_EXTENSION):
                exists = "exists"
            else:
                self.render_tile(tile_uri, x, y, z)

            self.printLock.acquire()
            print name, ":", z, x, y, exists
            self.printLock.release()
            self.q.task_done()
Beispiel #16
0
def test_hit_grid():
    import os
    from itertools import groupby

    def rle_encode(l):
        """ encode a list of strings with run-length compression """
        return ["%d:%s" % (len(list(group)), name) for name, group in groupby(l)]

    m = mapnik2.Map(256,256);
    mapnik2.load_map(m,'../data/good_maps/agg_poly_gamma_map.xml');
    m.zoom_all()
    join_field = 'NAME'
    fg = [] # feature grid
    for y in range(0, 256, 4):
        for x in range(0, 256, 4):
            featureset = m.query_map_point(0,x,y)
            added = False
            for feature in featureset.features:
                fg.append(feature[join_field])
                added = True
            if not added:
                fg.append('')
    hit_list = '|'.join(rle_encode(fg))
    eq_(hit_list[:16],'730:|2:Greenland')
    eq_(hit_list[-12:],'1:Chile|812:')
Beispiel #17
0
def serialize(xml, options):
    try:
        import mapnik2 as mapnik
    except:
        try:
            import mapnik
        except:
            sys.exit(
                color_text(
                    1,
                    'Error: saving xml requires Mapnik python bindings to be installed'
                ))
    m = mapnik.Map(1, 1)
    if options.from_string:
        mapnik.load_map_from_string(m, xml, True)
    else:
        mapnik.load_map(m, xml, True)
    if options.output:
        mapnik.save_map(m, options.output)
    else:
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 700:
            print mapnik.save_map_to_string(m)
        else:
            sys.exit(
                color_text(
                    1,
                    'Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file'
                ))
def serialize(xml, options):
    try:
        try:
            import mapnik2 as mapnik
        except ImportError:
            import mapnik
    except ImportError:
        sys.exit(color_text(1, "Error: saving xml requires Mapnik python bindings to be installed"))
    m = mapnik.Map(1, 1)
    if options.from_string:
        mapnik.load_map_from_string(m, xml, True)
    else:
        mapnik.load_map(m, xml, True)
    if options.output:
        mapnik.save_map(m, options.output)
    else:
        if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 700:
            print mapnik.save_map_to_string(m)
        else:
            sys.exit(
                color_text(
                    1,
                    "Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file",
                )
            )
Beispiel #19
0
    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) +
                                    ')')
Beispiel #20
0
    def loop(self, nb):
        self.m = mapnik.Map(TILES_SIZE, TILES_SIZE)
        # Load style XML
        mapnik.load_map(self.m, self.mapfile, True)
        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = GoogleProjection(self.maxZoom + 1)

        while True:
            #Fetch a tile from the queue and render it
            r = self.q.get()
            if (r == None):
                self.q.task_done()
                break
            else:
                (name, tile_uri, x, y, z) = r

            exists = ""
            if os.path.isfile(tile_uri + '.' + FILE_EXTENSION):
                exists = "exists"
            else:
                self.render_tile(tile_uri, x, y, z)

            self.printLock.acquire()
            print name, ":", z, x, y, exists
            self.printLock.release()
            self.q.task_done()
Beispiel #21
0
    def drawTile_bbox(self,bbox,imgx,imgy,fname):
        """Call Mapnik to draw a map image for data in
        bounding box bbox.  The image size is imgx by imgy pixels, and
        the output filename is fname.

        29sep2009  GJ  ORIGINAL VERSION, based on generate_image.py
        06jan2010  GJ  Renamed to drawTile_bbox from drawTile
        """
        mapfile = str(self.preferences_list['mapfile'])
        map_uri = str(fname)
        print ("mapfile=%s" % mapfile)

        # png image
        m = mapnik.Map(imgx,imgy)
        mapnik.load_map(m,mapfile)
        m.zoom_to_box(bbox)
        im = mapnik.Image(imgx,imgy)

        if HAS_MAPNIK2:
            # We apply the scale factor to the map
            print 'using scale factors from mapnik2'
            scale_factor = float( self.preferences_list['dpi'] ) / 72
            print "Scale factor is: ", scale_factor, "================="
            mapnik.render(m, im, scale_factor)
        else:
            print 'NOT using scale_factors'
            mapnik.render(m, im)
            
        view = im.view(0,0,imgx,imgy) # x,y,width,height
        view.save(map_uri,'png')
Beispiel #22
0
def test_hit_grid():
    import os
    from itertools import groupby

    def rle_encode(l):
        """ encode a list of strings with run-length compression """
        return [
            "%d:%s" % (len(list(group)), name) for name, group in groupby(l)
        ]

    m = mapnik2.Map(256, 256)
    mapnik2.load_map(m, '../data/good_maps/agg_poly_gamma_map.xml')
    m.zoom_all()
    join_field = 'NAME'
    fg = []  # feature grid
    for y in range(0, 256, 4):
        for x in range(0, 256, 4):
            featureset = m.query_map_point(0, x, y)
            added = False
            for feature in featureset.features:
                fg.append(feature[join_field])
                added = True
            if not added:
                fg.append('')
    hit_list = '|'.join(rle_encode(fg))
    eq_(hit_list[:16], '730:|2:Greenland')
    eq_(hit_list[-12:], '1:Chile|812:')
Beispiel #23
0
    def __init__(
            self, tilegrid, mapfile, data_buffer=128, image_buffer=0, output_format='png256', resolution=2,
            layers_fields={}, drop_empty_utfgrid=False, proj4_literal=None, **kwargs):
        """
        Constructs a MapnikTileStore

        :param tilegrid: the tilegrid.
        :param mapfile: the file used to render the tiles.
        :param buffer_size: the image buffer size default is 128.
        :param output_format: the output format,
            possible values 'jpeg', 'png', 'png256', 'grid',
            default is 'png256'
        :param layers: the layers and fields used in the grid generation,
            example: { 'my_layer': ['my_first_field', 'my_segonf_field']},
            default is {}.
        :param **kwargs: for extended class.
        """

        TileStore.__init__(self, **kwargs)
        self.tilegrid = tilegrid
        self.buffer = image_buffer
        self.output_format = output_format
        self.resolution = resolution
        self.layers_fields = layers_fields
        self.drop_empty_utfgrid = drop_empty_utfgrid

        self.mapnik = mapnik.Map(tilegrid.tile_size, tilegrid.tile_size)
        mapnik.load_map(self.mapnik, mapfile, True)
        self.mapnik.buffer_size = data_buffer
        if proj4_literal is not None:
            self.mapnik.srs = proj4_literal
Beispiel #24
0
    def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
        """
        """
        if self.mapnik is None:
            self.mapnik = mapnik.Map(0, 0)

            if exists(self.mapfile):
                mapnik.load_map(self.mapnik, str(self.mapfile))

            else:
                handle, filename = mkstemp()
                os.write(handle, urlopen(self.mapfile).read())
                os.close(handle)

                mapnik.load_map(self.mapnik, filename)
                os.unlink(filename)

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

        img = mapnik.Image(width, height)
        mapnik.render(self.mapnik, img)

        img = Image.fromstring("RGBA", (width, height), img.tostring())

        return img
Beispiel #25
0
    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
Beispiel #26
0
 def init_zoomlevel(self, z):
     self.currentz = z
     self.tilesize = getTileSize(NTILES[z], True)
     self.maps = {}
     for mapName in MAPNIK_LAYERS:
         console.debugMessage('Loading mapnik.Map: ' + mapName)
         self.maps[mapName] = mapnik.Map(self.tilesize, self.tilesize)
         mapnik.load_map(self.maps[mapName], mapName + ".xml")
Beispiel #27
0
 def compile(self, url, compile_callback):
     """ retrieve and compile a mapnik xml file. only called when the map
     is not already in static cache. calls compile_callback when  """
     self.mapnik_maps[url] = mapnik.Map(self.tilesize, self.tilesize)
     open("%s_compiled.xml" % self.filecache(url), 'w').write(
         cascadenik.compile(self.filecache(url), urlcache=True))
     mapnik.load_map(self.mapnik_maps[url], "%s_compiled.xml" % self.filecache(url))
     compile_callback(self.mapnik_maps[url])
Beispiel #28
0
 def init_zoomlevel(self, z):
     self.currentz = z
     self.tilesize = getTileSize(NTILES[z], True)
     self.maps = {}
     for mapName in MAPNIK_LAYERS:
         console.debugMessage('Loading mapnik.Map: ' + mapName)
         self.maps[mapName] = mapnik.Map(self.tilesize, self.tilesize)
         mapnik.load_map(self.maps[mapName], mapName + ".xml")
def test_load_save_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/raster_symbolizer.xml"
    mapnik2.load_map(map, in_map)

    out_map = mapnik2.save_map_to_string(map)
    assert 'RasterSymbolizer' in out_map
    assert 'RasterColorizer' in out_map
    assert 'stop' in out_map
Beispiel #30
0
def test_load_save_map():
    map = mapnik2.Map(256, 256)
    in_map = "../data/good_maps/raster_symbolizer.xml"
    mapnik2.load_map(map, in_map)

    out_map = mapnik2.save_map_to_string(map)
    assert 'RasterSymbolizer' in out_map
    assert 'RasterColorizer' in out_map
    assert 'ColorBand' in out_map
Beispiel #31
0
 def __init__(self, tile_dir, mapfile, q, maxZoom):
     self.tile_dir = tile_dir
     self.q = q
     self.m = mapnik.Map(256, 256)
     # Load style XML
     mapnik.load_map(self.m, mapfile, False)
     # Obtain <Map> projection
     self.prj = mapnik.Projection(self.m.srs)
     # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
     self.tileproj = GoogleProjection(maxZoom+1)
Beispiel #32
0
def test_gen_map():
    mapxmlfile = '../data/good_maps/raster_colorizer.xml'
    mapxmloutputfile = 'raster_colorizer_test_save.xml'
    outputfile = 'raster_colorizer_test.png'

    m = mapnik2.Map(800, 600)
    mapnik2.load_map(m, mapxmlfile)
    mapnik2.save_map(m, mapxmloutputfile)
    m.zoom_all()
    mapnik2.render_to_file(m, outputfile)
def test_gen_map():
    mapxmlfile = '../data/good_maps/raster_colorizer.xml'
    mapxmloutputfile = 'raster_colorizer_test_save.xml'
    outputfile = 'raster_colorizer_test.png'

    m = mapnik2.Map(800, 600)
    mapnik2.load_map(m, mapxmlfile)
    mapnik2.save_map(m, mapxmloutputfile)
    m.zoom_all()
    mapnik2.render_to_file(m, outputfile)
Beispiel #34
0
def assert_loads_successfully(file):
    m = mapnik2.Map(512, 512)

    strict = True
    mapnik2.load_map(m, file, strict)

    # libxml2 is not smart about paths, and clips the last directory off
    # of a path if it does not end in a trailing slash
    base_path = os.path.dirname(file) + '/'
    mapnik2.load_map_from_string(m, open(file, 'rb').read(), strict, base_path)
Beispiel #35
0
def assert_loads_successfully(file):
    m = mapnik2.Map(512, 512)

    strict = True
    mapnik2.load_map(m, file, strict)
    
    # libxml2 is not smart about paths, and clips the last directory off
    # of a path if it does not end in a trailing slash
    base_path = os.path.dirname(file) + '/'
    mapnik2.load_map_from_string(m,open(file,'rb').read(),strict,base_path)
 def __init__(self, tile_dir, mapfile, q, printLock, maxZoom):
     self.tile_dir = tile_dir
     self.q = q
     self.m = mapnik.Map(256, 256)
     self.printLock = printLock
     # Load style XML
     mapnik.load_map(self.m, mapfile, True)
     # Obtain <Map> projection
     self.prj = mapnik.Projection(self.m.srs)
     # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
     self.tileproj = GoogleProjection(maxZoom+1)
Beispiel #37
0
def run(image, stylesheet):
	#stylesheet = 'world_style.xml'
	#image = 'world_style.png'
	imgx = 600
	imgy = 300
	m = mapnik.Map(imgx, imgy)
	mapnik.load_map(m, stylesheet)
	m.zoom_all() 
	mapnik.render_to_file(m, image)
	#print "rendered image to '%s'" % image
	return image
Beispiel #38
0
def run(image, stylesheet):
    #stylesheet = 'world_style.xml'
    #image = 'world_style.png'
    imgx = 600
    imgy = 300
    m = mapnik.Map(imgx, imgy)
    mapnik.load_map(m, stylesheet)
    m.zoom_all()
    mapnik.render_to_file(m, image)
    #print "rendered image to '%s'" % image
    return image
 def __init__(self, tile_dir, mapfile, q, printLock, maxZoom):
     self.tile_dir = tile_dir
     self.q = q
     self.m = mapnik.Map(256, 256)
     self.printLock = printLock
     # Load style XML
     mapnik.load_map(self.m, mapfile, True)
     # Obtain <Map> projection
     self.prj = mapnik.Projection(self.m.srs)
     # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
     self.tileproj = spherical_mercator.SphericalMercator(maxZoom + 1)
Beispiel #40
0
 def add_region(self,name,mapfile,wkt_mask_file):
     # ignore attempts to add regions when no mask has been
     # specified with a warning.
     if self.mask_map is not None:
         try:
             m = Map(0,0)
             load_map(m, mapfile)
             mask = Mask(wkt_mask_file)
             self.regions.append((name,m,mask))
         except Exception as ex:
             mq_logging.error("Exception caught adding region (%s)" % str(ex))
     else:
         mq_logging.warning("Cannot add mask (%s) because no mask_style was configured." % name)
def test_load_save_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/raster_symbolizer.xml"
    try:
        mapnik2.load_map(map, in_map)
    
        out_map = mapnik2.save_map_to_string(map)
        assert 'RasterSymbolizer' in out_map
        assert 'RasterColorizer' in out_map
        assert 'stop' in out_map
    except RuntimeError, e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(str(e))
Beispiel #42
0
def get_paired_images(w, h, mapfile):
    tmp_map = 'tmp_map.xml'
    m = mapnik2.Map(w, h)
    mapnik2.load_map(m, mapfile)
    i = mapnik2.Image(w, h)
    m.zoom_all()
    mapnik2.render(m, i)
    mapnik2.save_map(m, tmp_map)
    m2 = mapnik2.Map(w, h)
    mapnik2.load_map(m2, tmp_map)
    i2 = mapnik2.Image(w, h)
    m2.zoom_all()
    mapnik2.render(m2, i2)
    os.remove(tmp_map)
    return i, i2
    def load_map(self):
        start = time.perf_counter()

        self.m = mapnik.Map(0, 0)
        # Load style XML
        if not self.opts.dry_run:
            mapnik.load_map(self.m, self.opts.mapfile, self.opts.mapnik_strict)

        end = time.perf_counter()
        info('[%s] Map loading took %.6fs', self.name, end - start)

        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = map_utils.GoogleProjection(opts.max_zoom + 1)
Beispiel #44
0
def get_paired_images(w,h,mapfile):
    tmp_map = 'tmp_map.xml'
    m = mapnik2.Map(w,h)
    mapnik2.load_map(m,mapfile)
    i = mapnik2.Image(w,h)
    m.zoom_all()
    mapnik2.render(m,i)
    mapnik2.save_map(m,tmp_map)
    m2 = mapnik2.Map(w,h)
    mapnik2.load_map(m2,tmp_map)
    i2 = mapnik2.Image(w,h)
    m2.zoom_all()
    mapnik2.render(m2,i2)
    os.remove(tmp_map)
    return i,i2    
Beispiel #45
0
    def __init__(self):
        self.MR['rpc_renderArea'] = {'minlat': [float, "Minimal latitude of map."],
                                     'minlon': [float, "Minimal longitude of map."],
                                     'maxlat': [float, "Maximal latitude of map."],
                                     'maxlon': [float, "Maximal longitude of map."],
        }
        self.MR['rpc_renderCoord'] = {'lat': [float, "Minimal latitude of map."],
                                      'lon': [float, "Minimal longitude of map."],
                                      'zoom': [float, "Maximal longitude of map."],
        }

        self.rendermap = mapnik.Map(self.mapsize[0], self.mapsize[1])
        mapnik.load_map(self.rendermap, self.mapfile)

        super(MapRenderer, self).__init__()
Beispiel #46
0
    def __init__(self, d, m):
        QObject.__init__(self)
        self.map_file = m
        self.tile_dir = d
        if not self.tile_dir.endswith('/'):
            self.tile_dir = self.tile_dir + '/'

        if not os.path.isdir(self.tile_dir):
            os.makedirs(self.tile_dir)

        self.m = mapnik2.Map(TILESIZE, TILESIZE)
        mapnik2.load_map(self.m, self.map_file, True)
        self.prj = mapnik2.Projection(self.m.srs)
        self.tileproj = GoogleProjection(MAX_ZOOM + 1)
        self.render_thread = RenderThread(self.m, self.prj, self.tileproj)
Beispiel #47
0
def assert_loads_successfully(file):
    m = mapnik2.Map(512, 512)

    try:
        strict = True
        mapnik2.load_map(m, file, strict)
        
        # libxml2 is not smart about paths, and clips the last directory off
        # of a path if it does not end in a trailing slash
        base_path = os.path.dirname(file) + '/'
        mapnik2.load_map_from_string(m,open(file,'rb').read(),strict,base_path)
    except RuntimeError, e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(e)
Beispiel #48
0
  def __init__(self, path_to_mapfile):
    self.max_zoom   = 22
    self.image_size = 256
    self.mapnik     = mapnik.Map(self.image_size, self.image_size)
    self.mapnik.srs = MERC_PROJ4
    self.mercator   = SphericalMercator(levels=self.max_zoom+1,size=self.image_size)

    mapnik.load_map(self.mapnik, path_to_mapfile)
    if not is_merc(self.mapnik.srs):
      self.mapnik_map.srs = MERC_PROJ4
      # NOTE: Add better logging
      print 'Forcing Merc Projection.'

    self.mapnik_map.zoom_all()
    self.envelope = self._mapnik_map.envelope()
Beispiel #49
0
    def load_map(self):
        start = time.perf_counter()

        self.m  = mapnik.Map(self.image_size, self.image_size)
        # Load style XML
        if not self.opts.dry_run:
            mapnik.load_map(self.m, self.opts.mapfile, self.opts.strict)

        end = time.perf_counter()
        info('[%s] Map loading took %.6fs', self.pid, end - start)

        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = map_utils.GoogleProjection(opts.max_zoom + 1)
Beispiel #50
0
    def _lazy_init_map(self):
        if self.m is None:
            #start = time.perf_counter()
            self.m = mapnik.Map(self.map_width, self.map_height)
            #print ("Mapnik took %r s" % (time.perf_counter()-start,))
            #start = time.perf_counter()
            if self.mapfile is None:
                self.m.background = mapnik.Color('rgb(0,0,0,0)')  #transparent
            else:
                mapnik.load_map(self.m, self.mapfile)
            #print ("loadint took %r s" % (time.perf_counter()-start,))
# Create a symbolizer to draw the points
#if "openstreetmap-carto" in mapfile:

            self.draw_gpx_track(self.gpx_file, self.gpx_style)
def test_gen_map():
    mapxmlfile = '../data/good_maps/raster_colorizer.xml'
    mapxmloutputfile = 'raster_colorizer_test_save.xml'
    outputfile = 'raster_colorizer_test.png'

    m = mapnik2.Map(800, 600)
    try:
        mapnik2.load_map(m, mapxmlfile)
        mapnik2.save_map(m, mapxmloutputfile)
        m.zoom_all()
        mapnik2.render_to_file(m, outputfile)
    except RuntimeError,e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(str(e))
    def run(self):
        self.mapnik_map = mapnik2.Map(self.width, self.height)
        mapnik2.load_map(self.mapnik_map, self.config, True)

        self.map_projection = mapnik2.Projection(self.mapnik_map.srs)
        self.tile_projection = GoogleProjection()  

        while True:
            try:
                tile_parameters = self.tile_queue.get_nowait()
            except Queue.Empty:
                break

            self.render_tile(*tile_parameters)
            self.tile_queue.task_done()
    def __init__(self, tile_dir, mapfile, q, printLock, maxZoom):
        self.tile_dir = tile_dir
        self.q = q
        self.m = mapnik.Map(256, 256)
        self.printLock = printLock
        # Load style XML
        mapnik.load_map(self.m, mapfile, True)
        # Obtain <Map> projection
        self.prj = mapnik.Projection(self.m.srs)
        # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
        self.tileproj = GoogleProjection(maxZoom + 1)

        # For testing if tiles are blank
        blankTile = mapnik.Image(256, 256)
        blankTile.background = mapnik.Color("rgba(0,0,0,0)")
        self.blankTileStr = blankTile.tostring("png")
Beispiel #54
0
def _pycairo_surface(type,sym):
    if mapnik2.has_pycairo():
        import cairo
        test_cairo_file = 'test.%s' % type
        m = mapnik2.Map(256,256)
        mapnik2.load_map(m,'../data/good_maps/%s_symbolizer.xml' % sym)
        surface = getattr(cairo,'%sSurface' % type.upper())(test_cairo_file, m.width,m.height)
        mapnik2.render(m, surface)
        surface.finish()        
        
        if os.path.exists(test_cairo_file):
            os.remove(test_cairo_file)
            return True
        else:
            # Fail, the file wasn't written
            return False
Beispiel #55
0
def _pycairo_surface(type, sym):
    if mapnik2.has_pycairo():
        import cairo
        test_cairo_file = 'test.%s' % type
        m = mapnik2.Map(256, 256)
        mapnik2.load_map(m, '../data/good_maps/%s_symbolizer.xml' % sym)
        surface = getattr(cairo, '%sSurface' % type.upper())(test_cairo_file,
                                                             m.width, m.height)
        mapnik2.render(m, surface)
        surface.finish()

        if os.path.exists(test_cairo_file):
            os.remove(test_cairo_file)
            return True
        else:
            # Fail, the file wasn't written
            return False
Beispiel #56
0
    def __init__(self):
        self.MR['rpc_renderArea'] = {
            'minlat': [float, "Minimal latitude of map."],
            'minlon': [float, "Minimal longitude of map."],
            'maxlat': [float, "Maximal latitude of map."],
            'maxlon': [float, "Maximal longitude of map."],
        }
        self.MR['rpc_renderCoord'] = {
            'lat': [float, "Minimal latitude of map."],
            'lon': [float, "Minimal longitude of map."],
            'zoom': [float, "Maximal longitude of map."],
        }

        self.rendermap = mapnik.Map(self.mapsize[0], self.mapsize[1])
        mapnik.load_map(self.rendermap, self.mapfile)

        super(MapRenderer, self).__init__()
def test_load_save_load_map():
    map = mapnik2.Map(256, 256)
    in_map = "../data/good_maps/glyph_symbolizer.xml"
    mapnik2.load_map(map, in_map)
    style = map.find_style('arrows')
    sym = style.rules[0].symbols[0]
    assert isinstance(sym, mapnik2.GlyphSymbolizer)
    assert sym.angle_mode == mapnik2.angle_mode.AZIMUTH

    out_map = mapnik2.save_map_to_string(map).decode('utf8')
    map = mapnik2.Map(256, 256)
    mapnik2.load_map_from_string(map, out_map.encode('utf8'))
    assert 'GlyphSymbolizer' in out_map
    assert 'RasterColorizer' in out_map
    # make sure non-ascii characters are well supported since most interesting
    # glyphs for symbology are usually in that range
    assert u'í' in out_map, out_map
Beispiel #58
0
    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)
Beispiel #59
0
    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