Esempio n. 1
0
def test_mutability_of_styles_from_iterator():
    """
    Should be able to mutate style by a reference
    returned from the iterator
    """
    p = mapnik.PointSymbolizer()
    p.allow_overlap = True
    p.opacity = 0.5

    r = mapnik.Rule()
    r.symbols.append(p)
    s = mapnik.Style()
    s.rules.append(r)
    m = mapnik.Map(256, 256)
    m.append_style('s', s)

    for style_name, style in m.styles:
        eq_(style_name, 's')
        eq_(len(style.rules), 1)
        style.rules.append(mapnik.Rule())
        eq_(len(style.rules), 2)

    for style_name, style in m.styles:
        eq_(style_name, 's')
        eq_(len(style.rules), 2)
Esempio n. 2
0
def test_mutability_of_styles_by_find_style():
    """
    Should be able to mutate style by a reference
    returned from find_style()
    """
    p = mapnik.PointSymbolizer()
    p.allow_overlap = True
    p.opacity = 0.5

    r = mapnik.Rule()
    r.symbols.append(p)
    s = mapnik.Style()
    s.rules.append(r)
    m = mapnik.Map(256, 256)
    m.append_style('s', s)

    s2 = m.find_style('s')
    eq_(len(s2.rules), 1)

    s3 = m.find_style('s')
    s3.rules.append(mapnik.Rule())

    # Both referefences should point to the same object
    eq_(len(s3.rules), 2)
    eq_(len(s2.rules), 2)
Esempio n. 3
0
    def __add_manholes(self, layers, styles):
        "Add manhole layer and styles."

        # Select the manholes that are part of this sewerage.

        manholes = Manhole.objects.filter(sewerage__pk=self.id)

        # Define a style.

        style = mapnik.Style()

        # Style the `normal` manholes.

        rule = mapnik.Rule()
        rule.filter = mapnik.Filter("[sink] != 1")
        symbol = mapnik.PointSymbolizer()
        symbol.allow_overlap = True
        rule.symbols.append(symbol)
        style.rules.append(rule)

        # Style the sink.

        rule = mapnik.Rule()
        rule.filter = mapnik.Filter("[sink] = 1")
        symbol = mapnik.PointSymbolizer(
            str(finders.find("lizard_riool/sink.png")), "png", 8, 8
        )
        symbol.allow_overlap = True
        rule.symbols.append(symbol)
        style.rules.append(rule)

        # Add labels.

        rule = mapnik.Rule()
        rule.max_scale = 1700
        symbol = mapnik.TextSymbolizer(
            'code', 'DejaVu Sans Book', 10, mapnik.Color('black')
        )
        symbol.allow_overlap = True
        symbol.label_placement = mapnik.label_placement.POINT_PLACEMENT
        symbol.vertical_alignment = mapnik.vertical_alignment.TOP
        symbol.displacement(0, -5)  # slightly above
        rule.symbols.append(symbol)
        style.rules.append(rule)

        # Setup datasource.

        params = default_database_params()
        params['table'] = "({}) data".format(manholes.query)
        datasource = mapnik.PostGIS(**params)

        # Define layer.

        layer = mapnik.Layer('manholeLayer')
        layer.datasource = datasource
        layer.maxzoom = 35000
        layer.styles.append('manholeStyle')

        layers.append(layer)
        styles['manholeStyle'] = style
Esempio n. 4
0
        def __init__(self):
            BaseWMSFactory.__init__(self)

            layer = mapnik.Layer('TOP', modis_srs)
            layer.datasource = mapnik.Gdal(file=str(data),band=1) 
            layer.title = "Modis VI Layer"
            layer.queryable = True
            layer.wms_srs = None
            style = mapnik.Style()
            rule = mapnik.Rule()
            sym = mapnik.RasterSymbolizer()
            sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE, mapnik.Color("transparent"))
            scale = getModisScale(product)
            for color in scale:
                sym.colorizer.add_stop(color['stop'], mapnik.Color(*color['color']))
            rule.symbols.append(sym)
            style.rules.append(rule)
            self.register_style('modis_style', style)
            self.register_layer(layer, "modis_style",("modis_style",))

            layer = mapnik.Layer('ocean_mask')
            layer.datasource = mapnik.Shapefile(file=str("/data/health/data1/web/data/shapes/50m_ocean.shp"))
            layer.queryable = True
            layer.wms_srs = None
            style = mapnik.Style()
            rule = mapnik.Rule()
            poly_sym = mapnik.PolygonSymbolizer(mapnik.Color('#50649B'))
            rule.symbols.append(poly_sym)
            style.rules.append(rule)
            self.register_style('mask_style', style)
            self.register_layer(layer, "mask_style",("mask_style",))
Esempio n. 5
0
    def layer(self, layer_ids=None, request=None):
        """Return mapnik layers and styles."""
        layers = []
        styles = {}
        style = mapnik.Style()
        styles["riverlineadapterstyle"] = style

        if self.riverline_result.is_reference:
            range_method = self._reference_ranges
            level_field = 'level'
        else:
            range_method = self._ranges
            level_field = 'relative_level'
        for from_, to_, color in range_method():
            rule = mapnik.Rule()
            if from_ is None:
                rule.filter = mapnik.Filter("[value] < %s" % to_)
            elif to_ is None:
                rule.filter = mapnik.Filter("[value] > %s" % from_)
            else:
                rule.filter = mapnik.Filter("[value] > %s and [value] < %s" %
                                            (from_, to_))
            symbol = mapnik.LineSymbolizer(
                mapnik.Color(color[0], color[1], color[2]), 3)
            rule.symbols.append(symbol)
            style.rules.append(rule)

        # Catch all rule for unknown states:
        rule = mapnik.Rule()
        rule.set_else(True)
        symbol = mapnik.LineSymbolizer(mapnik.Color(100, 100, 100), 3)
        rule.symbols.append(symbol)
        style.rules.append(rule)

        query = """(
            select riverline.the_geom, row.%s as value
            from lizard_rijnmond_riverline riverline,
            lizard_rijnmond_riverlineresultdata row
            where riverline.verbose_code = row.location
            and row.riverline_result_id = %s
        ) as data""" % (level_field, self.riverline_result_id)
        logger.info(query)
        default_database = settings.DATABASES['default']
        datasource = mapnik.PostGIS(
            host=default_database['HOST'],
            user=default_database['USER'],
            password=default_database['PASSWORD'],
            dbname=default_database['NAME'],
            table=str(query),
        )

        layer = mapnik.Layer("Riverlines", coordinates.RD)
        layer.datasource = datasource
        layer.styles.append("riverlineadapterstyle")
        layers.append(layer)

        return layers, styles
Esempio n. 6
0
    def test_psql_error_should_give_back_connections_opened_for_lower_layers_to_the_pool():
        map1 = mapnik.Map(600,300)
        s = mapnik.Style()
        r = mapnik.Rule()
        r.symbols.append(mapnik.PolygonSymbolizer())
        s.rules.append(r)
        map1.append_style('style',s)

        # This layer will fail after a while
        buggy_s = mapnik.Style()
        buggy_r = mapnik.Rule()
        buggy_r.symbols.append(mapnik.PolygonSymbolizer())
        buggy_r.filter = mapnik.Filter("[fips] = 'FR'")
        buggy_s.rules.append(buggy_r)
        map1.append_style('style for buggy layer',buggy_s)
        buggy_layer = mapnik.Layer('this layer is buggy at runtime')
        # We ensure the query wille be long enough
        buggy_layer.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='(SELECT geom as geom, pg_sleep(0.1), fips::int from world_merc) as failure_tabl',
            max_async_connection=2, max_size=2,asynchronous_request = True, geometry_field='geom')
        buggy_layer.styles.append('style for buggy layer')

        # The query for this layer will be sent, then the previous layer will raise an exception before results are read
        forced_canceled_layer = mapnik.Layer('this layer will be canceled when an exception stops map rendering')
        forced_canceled_layer.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='world_merc',
            max_async_connection=2, max_size=2, asynchronous_request = True, geometry_field='geom')
        forced_canceled_layer.styles.append('style')

        map1.layers.append(buggy_layer)
        map1.layers.append(forced_canceled_layer)
        map1.zoom_all()
        map2 = mapnik.Map(600,300)
        map2.background = mapnik.Color('steelblue')
        s = mapnik.Style()
        r = mapnik.Rule()
        r.symbols.append(mapnik.LineSymbolizer())
        r.symbols.append(mapnik.LineSymbolizer())
        s.rules.append(r)
        map2.append_style('style',s)
        layer1 = mapnik.Layer('layer1')
        layer1.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='world_merc',
            max_async_connection=2, max_size=2, asynchronous_request = True, geometry_field='geom')
        layer1.styles.append('style')
        map2.layers.append(layer1)
        map2.zoom_all()

        # We expect this to trigger a PSQL error
        try:
            mapnik.render_to_file(map1,'/tmp/mapnik-postgis-test-map1.png', 'png')
            # Test must fail if error was not raised just above
            eq_(False,True)
        except RuntimeError:
            pass
        # This used to raise an exception before correction of issue 2042
        mapnik.render_to_file(map2,'/tmp/mapnik-postgis-test-map2.png', 'png')
Esempio n. 7
0
 def singlePolyStyle(self,
                     clr,
                     outlineColor="#000000",
                     outlineThikness=0.1):
     polyS = mapnik.Style()
     r = mapnik.Rule()
     s = mapnik.PolygonSymbolizer(mapnik.Color(clr))
     r.symbols.append(s)
     polyS.rules.append(r)
     r = mapnik.Rule()
     s = mapnik.LineSymbolizer(mapnik.Color(outlineColor), outlineThikness)
     r.symbols.append(s)
     polyS.rules.append(r)
     return polyS
Esempio n. 8
0
def index(request):
    m = mapnik.Map(700, 700)
    m.background = mapnik.Color("white")
    

    polygons = mapnik.PolygonSymbolizer()
    polygons.fill = mapnik.Color("orange")

    rules = mapnik.Rule()
    rules.symbols.append(polygons)

    style = mapnik.Style()
    style.rules.append(rules)

    # Creating rules 
    highlight = mapnik.PolygonSymbolizer()

    highlight.fill = mapnik.Color('red')
    r = mapnik.Rule()
    r.filter = mapnik.Expression("[productivi] <= 31")
    r.symbols.append(highlight)
    style.rules.append(r)

    highlight.fill = mapnik.Color('green')
    g = mapnik.Rule()
    g.filter = mapnik.Expression("[productivi] >= 70")
    g.symbols.append(highlight)
    style.rules.append(g)


    m.append_style('Polygons', style)

    layer = mapnik.Layer('A')

    layer.datasource = mapnik.PostGIS(host='127.0.0.1',user='******', \
                                        password='******',dbname='geotest', \
                                        table='map_map', srid='3857')
    layer.styles.append('Polygons')
    m.layers.append(layer)


    rules.symbols.append(polygons)
    style.rules.append(rules)

    m.zoom_all()
    mapnik.render_to_file(m, os.path.abspath('FileStorage/polygons.png'), 'png')
    
    return render(request, 'base.html')
def test_that_coordinates_do_not_overflow_and_polygon_is_rendered_csv():
    expected_color = mapnik.Color('white')
    projection = '+init=epsg:4326'
    ds = mapnik.MemoryDatasource()
    context = mapnik.Context()
    feat = mapnik.Feature.from_geojson(json.dumps(geojson), context)
    ds.add_feature(feat)
    geojson_string = "geojson\n'%s'" % json.dumps(geojson['geometry'])
    ds = mapnik.Datasource(**{'type': 'csv', 'inline': geojson_string})
    s = mapnik.Style()
    r = mapnik.Rule()
    sym = mapnik.PolygonSymbolizer()
    sym.fill = expected_color
    r.symbols.append(sym)
    s.rules.append(r)
    lyr = mapnik.Layer('Layer', projection)
    lyr.datasource = ds
    lyr.styles.append('style')
    m = mapnik.Map(256, 256, projection)
    m.background_color = mapnik.Color('green')
    m.append_style('style', s)
    m.layers.append(lyr)
    # 17/20864/45265.png
    m.zoom_to_box(
        mapnik.Box2d(-13658379.710221574, 6197514.253362091,
                     -13657768.213995293, 6198125.749588372))
    # works 15/5216/11316.png
    # m.zoom_to_box(mapnik.Box2d(-13658379.710221574,6195679.764683247,-13655933.72531645,6198125.749588372))
    im = mapnik.Image(256, 256)
    mapnik.render(m, im)
    eq_(im.get_pixel(128, 128), expected_color.packed())
Esempio n. 10
0
def test_raster_warping():
    lyrSrs = "+init=epsg:32630"
    mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
    lyr = mapnik.Layer('dataraster', lyrSrs)
    if 'gdal' in mapnik.DatasourceCache.plugin_names():
        lyr.datasource = mapnik.Gdal(
            file='../data/raster/dataraster.tif',
            band=1,
        )
        sym = mapnik.RasterSymbolizer()
        sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
                                               mapnik.Color(255, 255, 0))
        rule = mapnik.Rule()
        rule.symbols.append(sym)
        style = mapnik.Style()
        style.rules.append(rule)
        _map = mapnik.Map(256, 256, mapSrs)
        _map.append_style('foo', style)
        lyr.styles.append('foo')
        _map.layers.append(lyr)
        map_proj = mapnik.Projection(mapSrs)
        layer_proj = mapnik.Projection(lyrSrs)
        prj_trans = mapnik.ProjTransform(map_proj, layer_proj)
        _map.zoom_to_box(prj_trans.backward(lyr.envelope()))

        im = mapnik.Image(_map.width, _map.height)
        mapnik.render(_map, im)
        imdata = im.tostring()
        assert contains_word('\xff\xff\x00\xff', imdata)
Esempio n. 11
0
def test_raster_warping_does_not_overclip_source():
    lyrSrs = "+init=epsg:32630"
    mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
    lyr = mapnik.Layer('dataraster', lyrSrs)
    if 'gdal' in mapnik.DatasourceCache.plugin_names():
        lyr.datasource = mapnik.Gdal(
            file='../data/raster/dataraster.tif',
            band=1,
        )
        sym = mapnik.RasterSymbolizer()
        sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
                                               mapnik.Color(255, 255, 0))
        rule = mapnik.Rule()
        rule.symbols.append(sym)
        style = mapnik.Style()
        style.rules.append(rule)
        _map = mapnik.Map(256, 256, mapSrs)
        _map.background = mapnik.Color('white')
        _map.append_style('foo', style)
        lyr.styles.append('foo')
        _map.layers.append(lyr)
        _map.zoom_to_box(mapnik.Box2d(3, 42, 4, 43))

        im = mapnik.Image(_map.width, _map.height)
        mapnik.render(_map, im)
        assert im.view(0, 200, 1, 1).tostring() == '\xff\xff\x00\xff'
Esempio n. 12
0
def mapnik_lyr(mapobj, data=None, line_sym=None):
    ################################################################################
    # m = mapnik.Map(600, 300, "+proj=latlong +datum=WGS84")
    s = mapnik.Style()
    r = mapnik.Rule()
    r.symbols.append(line_sym)
    s.rules.append(r)
    sname = str(int(time.time()))
    print(sname)
    time.sleep(1)
    mapobj.append_style(sname, s)

    # line_symbolizer = mapnik.LineSymbolizer()
    # line_symbolizer.stroke = mapnik.Color('rgb(100%,50%,50%)')
    # ################################################################################
    # line_symbolizer.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
    #
    # line_symbolizer.stroke_width = 4.0
    #
    # s2 = mapnik.Style()
    # r2 = mapnik.Rule()
    # r2.symbols.append(line_symbolizer)
    # s2.rules.append(r2)
    # mapobj.append_style('My Style2', s2)

    lyr = mapnik.Layer('world', "+proj=latlong +datum=WGS84")
    # lyr.datasource = mapnik.Shapefile(file='/gdata/world_borders.shp')
    lyr.datasource = mapnik.Shapefile(file=data)
    lyr.styles.append(sname)

    return lyr
Esempio n. 13
0
def renderit(line_sym=None, poly_sym=None, point_sym=None, shpfile=None, fig_index=0):
    ################################################################################
    m = mapnik.Map(600, 300, "+proj=latlong +datum=WGS84")
    s = mapnik.Style()
    r = mapnik.Rule()
    # line_sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
    # line_sym.stroke_linejoin = mapnik.stroke_linejoin.ROUND_JOIN
    # line_sym.stroke_dasharray = [(3,4)]
    # line_sym.stroke_linecap = mapnik.stroke_linecap.SQUARE_CAP

    if poly_sym:
        r.symbols.append(poly_sym)
    if point_sym:
        r.symbols.append(point_sym)
    if line_sym:
        r.symbols.append(line_sym)
    s.rules.append(r)
    m.append_style('My Style', s)
    lyr = mapnik.Layer('world', "+proj=latlong +datum=WGS84")
    # lyr.datasource = mapnik.Shapefile(file='/gdata/world_borders.shp')
    if shpfile:
        lyr.datasource = mapnik.Shapefile(file=shpfile)
    else:
        lyr.datasource = mapnik.Shapefile(file=os.path.join(BASE_PATH, 'fig_data_line.shp'))
    lyr.styles.append('My Style')
    m.layers.append(lyr)
    # bbox = mapnik.Box2d(118, 36.6, 124.6, 40.7)
    # m.zoom_to_box(bbox)
    m.zoom_all()
    return m
Esempio n. 14
0
def init_map(zoom, seq):
    m = mapnik.Map(256, 256, merc_srs)
    m.background_color = mapnik.Color('white')
    s = mapnik.Style()
    r = mapnik.Rule()
    sym = mapnik.MarkersSymbolizer()
    sym.fill = mapnik.Color('black')
    sym.spacing = 0.0
    sym.opacity = opacity(zoom)
    sym.height = mapnik.Expression(str(pointWeight(zoom) / 2.0))
    sym.width = mapnik.Expression(str(pointWeight(zoom) / 2.0))

    # Ignore placement instructs Mapnik to avoid building the quadtree
    # collision cache and helps performance if you know you want to
    # allow for overlaps between features.
    #        - Dane
    sym.allow_overlap = True
    sym.ignore_placement = True

    r.symbols.append(sym)
    s.rules.append(r)
    m.append_style('point_style', s)
    TuplesDatasource.set_source(seq)
    ds = mapnik.Python(factory='TuplesDatasource')
    layer = mapnik.Layer('file', merc_srs)
    layer.datasource = ds
    layer.styles.append('point_style')
    m.layers.append(layer)
    return m
Esempio n. 15
0
    def _addStyleToMap(self, m, layerSrs, colorizer=None, band=-1, extent=None,
                       composite=None, nodata=None):
        """
        Add a mapik raster symbolizer to a map.

        :param m: mapnik map.
        :param layerSrs: the layer projection
        :param colorizer: a mapnik colorizer.
        :param band: an integer band number.  -1 for default.
        :param extent: the extent to use for the mapnik layer.
        :param composite: the composite operation to use.  This is one of
            mapnik.CompositeOp.xxx, typically lighten or multiply.
        :param nodata: the value to use for missing data or None to use all
            data.
        """
        styleName = 'Raster Style'
        if band != -1:
            styleName += ' ' + str(band)
        rule = mapnik.Rule()
        sym = mapnik.RasterSymbolizer()
        if colorizer is not None:
            sym.colorizer = colorizer
        rule.symbols.append(sym)
        style = mapnik.Style()
        style.rules.append(rule)
        if composite is not None:
            style.comp_op = composite
        m.append_style(styleName, style)
        lyr = mapnik.Layer('layer')
        lyr.srs = layerSrs
        lyr.datasource = mapnik.Gdal(
            base=None, file=self._path, band=band, extent=extent, nodata=nodata)
        lyr.styles.append(styleName)
        m.layers.append(lyr)
Esempio n. 16
0
    def addPreviewToMap(self, name, scaleDenoms, filter, symbol_type,
                        datasource, layerSRS, prevColor):
        s = mapnik.Style()
        r = mapnik.Rule()
        if symbol_type == 'polygon':
            polygon_symbolizer = mapnik.PolygonSymbolizer(
                mapnik.Color(prevColor))
            r.symbols.append(polygon_symbolizer)
        elif symbol_type == 'line':
            line_symbolizer = mapnik.LineSymbolizer(mapnik.Color(prevColor), 3)
            r.symbols.append(line_symbolizer)
#        elif symbol_type == 'text':
#           t = mapnik.TextSymbolizer('FIELD_NAME', 'DejaVu Sans Book', 10, Color('black'))
#          t.halo_fill = Color('white')
#         t.halo_radius = 1
#        t.label_placement = label_placement.LINE_PLACEMENT
#       r.symbols.append(line_symbolizer)
        else:
            print symbol_type, 'has to be implemented to preview!!!'
        if filter != None:
            #f = mapnik.Expression("[waterway] != ''") #'Expression' stands for 'Filter' as this will be replaced in Mapnik3
            r.filter = filter  #f
            if scaleDenoms != -1:
                r.min_scale = scaleDenoms[0]
                r.max_scale = scaleDenoms[1]
        s.rules.append(r)

        proof = self.tileParams.getMapnikMap().append_style(name, s)
        layer = mapnik.Layer('world')
        layer.datasource = datasource[1]
        layer.srs = layerSRS
        layer.styles.append(name)
        self.tileParams.getMapnikMap().layers.append(layer)
Esempio n. 17
0
def rgb_style():
    rgb_symb = mapnik.RasterSymbolizer()
    rgb_rule = mapnik.Rule()
    rgb_rule.symbols.append(rgb_symb)
    rgb_style = mapnik.Style()
    rgb_style.rules.append(rgb_rule)
    return rgb_style
Esempio n. 18
0
def test_raster_with_alpha_blends_correctly_with_background():
    WIDTH = 500
    HEIGHT = 500

    map = mapnik.Map(WIDTH, HEIGHT)
    WHITE = mapnik.Color(255, 255, 255)
    map.background = WHITE

    style = mapnik.Style()
    rule = mapnik.Rule()
    symbolizer = mapnik.RasterSymbolizer()
    symbolizer.scaling = mapnik.scaling_method.BILINEAR

    rule.symbols.append(symbolizer)
    style.rules.append(rule)

    map.append_style('raster_style', style)

    map_layer = mapnik.Layer('test_layer')
    filepath = '../data/raster/white-alpha.png'
    if 'gdal' in mapnik.DatasourceCache.plugin_names():
        map_layer.datasource = mapnik.Gdal(file=filepath)
        map_layer.styles.append('raster_style')
        map.layers.append(map_layer)

        map.zoom_all()

        mim = mapnik.Image(WIDTH, HEIGHT)

        mapnik.render(map, mim)
        imdata = mim.tostring()
        # All white is expected
        eq_(get_unique_colors(mim),['rgba(254,254,254,255)'])
Esempio n. 19
0
    def style_map(self, Map):
        style = mapnik.Style()
        rule = mapnik.Rule()

        sym = mapnik.RasterSymbolizer()
        sym.opacity = self.opacity

        colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE,
                                           mapnik.Color('white'))
        # colorizer.epsilon = 0.001
        if self.colormap:
            for stop in self.colormap:
                colorizer.add_stop(stop['quantity'],
                                   mapnik.Color(stop['color'].encode('ascii')))

        sym.colorizer = colorizer

        rule.symbols.append(sym)
        style.rules.append(rule)

        Map.append_style('Raster Style', style)

        lyr = mapnik.Layer('GDAL Layer from TIFF', self.layer_srs)

        lyr.datasource = mapnik.Gdal(base=os.path.dirname(self.vrt_path),
                                     file=os.path.basename(self.vrt_path),
                                     band=self.mapnik_band)

        lyr.styles.append('Raster Style')

        Map.layers.append(lyr)

        return Map
Esempio n. 20
0
    def render_png(self, show=True):
        import mapnik
        #TODO scale dimensions to aspect ratio of data
        m = mapnik.Map(800, 400)
        m.background = mapnik.Color('white')
        s = mapnik.Style()
        r = mapnik.Rule()

        if "point" in self.collection().schema['geometry'].lower():
            point_symbolizer = mapnik.PointSymbolizer()
            r.symbols.append(point_symbolizer)
        else:
            polygon_symbolizer = mapnik.PolygonSymbolizer(
                mapnik.Color('#f2eff9'))
            r.symbols.append(polygon_symbolizer)

            line_symbolizer = mapnik.LineSymbolizer(
                mapnik.Color('rgb(50%,50%,50%)'), 0.8)
            r.symbols.append(line_symbolizer)

        s.rules.append(r)
        m.append_style('My Style', s)
        ds = mapnik.Shapefile(file=self.path)
        layer = mapnik.Layer('world')
        layer.datasource = ds
        layer.styles.append('My Style')
        m.layers.append(layer)
        m.zoom_all()
        outfile = '/tmp/world.png'
        mapnik.render_to_file(m, outfile, 'png')
        if show:
            im = Image.open(outfile)
            im.show()
        return outfile
Esempio n. 21
0
def create_grid_map(width,height):
    places_ds = mapnik.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 = mapnik.Style()
    r = mapnik.Rule()
    #symb = mapnik.PointSymbolizer()
    symb = mapnik.MarkersSymbolizer()
    symb.allow_overlap = True
    r.symbols.append(symb)
    label = mapnik.TextSymbolizer(mapnik.Expression('[Name]'),
                'DejaVu Sans Book',
                10,
                mapnik.Color('black')
                )
    label.allow_overlap = True
    label.displacement = (0,-10)
    #r.symbols.append(label)

    s.rules.append(r)
    lyr = mapnik.Layer('Places')
    lyr.datasource = places_ds
    lyr.styles.append('places_labels')
    m = mapnik.Map(width,height)
    m.append_style('places_labels',s)
    m.layers.append(lyr)
    return m
Esempio n. 22
0
    def __call__(self, feature_layers):
        # take the feature_layers dict and generate a gif response

        # this just puts all the features across all layers into a
        # single one, and then just renders them all with a very
        # simple style as a proof of concept
        # we probably want to do this per layer with a separate style
        # for each
        features = feature_layers_to_features_list(feature_layers)

        layer = mapnik.Layer('tile')
        memds = mapnik.MemoryDatasource()
        ctx = mapnik.Context()
        for feature in features:
            wkb, properties, fid = feature
            for key in properties.keys():
                ctx.push(key.encode('utf-8'))
        i = 1
        for feature in features:
            wkb, properties, fid = feature
            mf = mapnik.Feature(ctx, i)
            i += 1
            mf.add_geometries_from_wkb(wkb)
            for k, v in properties.items():
                mf[k.encode('utf-8')] = str(v)
                memds.add_feature(mf)

        layer.datasource = memds

        m = mapnik.Map(256, 256)

        m.background = mapnik.Color('blue')

        s = mapnik.Style()
        r = mapnik.Rule()
        polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))
        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)
        layer.styles.append('my style')

        m.layers.append(layer)
        m.zoom_all()
        # from mapnik import Image
        # im = Image(m.width, m.height)
        # mapnik.render(m, im)
        # png_contents = im.tostring()

        # this was just the easiest way for me to get this to work
        import tempfile
        tmpfile = tempfile.NamedTemporaryFile()
        with tmpfile.file as fp:
            mapnik.render_to_file(m, tmpfile.name, 'png')
            fp.seek(0)
            png_contents = fp.read()

        return png_contents
Esempio n. 23
0
    def addPreviewOfGeneralizedGeometriesToMap(self, table_name, symbol_type,
                                               layerSRS, name):
        genColor = 'rgb(0%,0%,100%)'
        s = mapnik.Style()
        r = mapnik.Rule()
        if symbol_type == 'polygon':
            polygon_symbolizer = mapnik.PolygonSymbolizer(
                mapnik.Color(genColor))
            r.symbols.append(polygon_symbolizer)
        elif symbol_type == 'line':
            line_symbolizer = mapnik.LineSymbolizer(mapnik.Color(genColor), 2)
            r.symbols.append(line_symbolizer)
        else:
            print symbol_type, 'has to be implemented to preview!!!'
        s.rules.append(r)
        self.tileParams.getMapnikMap().append_style(name, s)

        lyr = mapnik.Layer('Generalized geometry from PostGIS')
        lyr.datasource = mapnik.PostGIS(host='localhost',
                                        user='******',
                                        password='******',
                                        dbname='meingis',
                                        table='(select geom from ' +
                                        table_name + ' ) as geometries')
        lyr.srs = layerSRS
        lyr.styles.append(name)
        self.tileParams.getMapnikMap().layers.append(lyr)
Esempio n. 24
0
def create_rule(expression, color):
    rule = mapnik.Rule()
    rule.filter = mapnik.Expression(expression)
    point_symbolizer = mapnik.MarkersSymbolizer()
    point_symbolizer.fill = mapnik.Color(*color)
    rule.symbols.append(point_symbolizer)
    return rule
Esempio n. 25
0
def test_raster_warping_does_not_overclip_source():
    lyrSrs = "+init=epsg:32630"
    mapSrs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
    lyr = mapnik.Layer('dataraster', lyrSrs)
    if 'gdal' in mapnik.DatasourceCache.plugin_names():
        lyr.datasource = mapnik.Gdal(
            file = '../data/raster/dataraster.tif',
            band = 1,
            )
        sym = mapnik.RasterSymbolizer()
        sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_DISCRETE, mapnik.Color(255,255,0))
        rule = mapnik.Rule()
        rule.symbols.append(sym)
        style = mapnik.Style()
        style.rules.append(rule)
        _map = mapnik.Map(256,256, mapSrs)
        _map.background=mapnik.Color('white')
        _map.append_style('foo', style)
        lyr.styles.append('foo')
        _map.layers.append(lyr)
        _map.zoom_to_box(mapnik.Box2d(3,42,4,43))

        im = mapnik.Image(_map.width,_map.height)
        mapnik.render(_map, im)
        expected_file = './images/support/raster_warping_does_not_overclip_source.png'
        actual_file = '/tmp/' + os.path.basename(expected_file)
        im.save(actual_file,'png32')
        if not os.path.exists(expected_file) or os.environ.get('UPDATE'):
            im.save(expected_file,'png32')
        actual = mapnik.Image.open(actual_file)
        expected = mapnik.Image.open(expected_file)
        eq_(actual.tostring('png32'),expected.tostring('png32'), 'failed comparing actual (%s) and expected (%s)' % (actual_file,expected_file))
Esempio n. 26
0
        def __init__(self):
            BaseWMSFactory.__init__(self)
            for data in datas:
                name = data['name']
                title = data['long_name']      
                data = base_path+"/ecohealth/"+name+'.asc'
                
                layer = mapnik.Layer(name,"+init=epsg:4326")
                layer.datasource = mapnik.Gdal(file=str(data),band=1) 
                layer.title = title
                layer.queryable = True
                layer.wms_srs = None
                style = mapnik.Style()
                rule = mapnik.Rule()
                sym = mapnik.RasterSymbolizer()
                sym.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, mapnik.Color("transparent"))
                scale = getEcohealthScale(name)
                for color in scale:
                    sym.colorizer.add_stop(color['stop'], mapnik.Color(*color['color']))
                rule.symbols.append(sym)
                style.rules.append(rule)

                self.register_style(name,style)
                self.register_layer(layer, name, (name,))
            self.finalize()
Esempio n. 27
0
    def __init__(self, id, file, fill_color, stroke_color, stroke_width):
        """Creates a shape layer."""
        super(ShapeLayer, self).__init__()
        self.id = id
        self.file = file
        self.fill_color = fill_color
        self.stroke_color = stroke_color
        self.stroke_width = stroke_width
        ds = mapnik.Shapefile(file=(os.path.splitext(file)[0]))
        srs = self._srs(file)
        self.mapnik_layer = mapnik.Layer('Shapefile Layer', srs)
        self.mapnik_layer.datasource = ds
        self.mapnik_layer.maximum_extent = self._extent(file)

        polygon_symbolizer = mapnik.PolygonSymbolizer()
        polygon_symbolizer.fill = mapnik.Color(str(fill_color))

        line_symbolizer = mapnik.LineSymbolizer()
        line_symbolizer.stroke = mapnik.Color(str(stroke_color))
        line_symbolizer.stroke_width = float(stroke_width)

        rule = mapnik.Rule()
        rule.symbols.append(polygon_symbolizer)
        rule.symbols.append(line_symbolizer)
        style = mapnik.Style()
        style.rules.append(rule)
        self.mapnik_style = style
        self.mapnik_layer.styles.append('Shapefile Layer')
Esempio n. 28
0
    def _render_shape_file(self, shape_file, color, line_width):
        LOG.debug("render_shape_file")
        shape_file.flush()

        shpid = os.path.basename(shape_file.get_filepath())
        s, r = mapnik.Style(), mapnik.Rule()

        if ocitysmap.get_mapnik_major_version() == 2:
            r.symbols.append(mapnik.PolygonSymbolizer(color))
            r.symbols.append(mapnik.LineSymbolizer(color, line_width))
        else:
            poly_sym = mapnik.PolygonSymbolizer()
            poly_sym.fill = color
            r.symbols.append(poly_sym)
            line_sym = mapnik.LineSymbolizer()
            line_sym.stroke = color
            line_sym.stroke_width = float(line_width)
            r.symbols.append(line_sym)
            s.rules.append(r)

        self._map.append_style('style_%s' % shpid, s)
        layer = mapnik.Layer(shpid)
        layer.datasource = mapnik.Shapefile(file=shape_file.get_filepath())
        layer.styles.append('style_%s' % shpid)

        self._map.layers.append(layer)
Esempio n. 29
0
def create_map_and_append_symbolyzer(sym):
    srs = '+init=epsg:32630'
    lyr = mapnik.Layer('arrows')
    try:
        lyr.datasource = mapnik.Shapefile(file='../data/shp/arrows.shp', )
        lyr.srs = srs
        _map = mapnik.Map(256, 256, srs)
        style = mapnik.Style()
        rule = mapnik.Rule()
        rule.symbols.append(sym)

        # put a test symbolizer to see what is the azimuth being read
        ts = mapnik.TextSymbolizer(mapnik.Expression('[azimuth]'),
                                   "DejaVu Sans Book", 10,
                                   mapnik.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(mapnik.Box2d(0, 0, 8, 8))
        return _map
    except RuntimeError, e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(e)
Esempio n. 30
0
def test_that_coordinates_do_not_overflow_and_polygon_is_rendered():
    expected_color = mapnik.Color('white')
    ds = mapnik.MemoryDatasource()
    context = mapnik.Context()
    ds.add_feature(mapnik.Feature.from_geojson(json.dumps(geojson), context))
    s = mapnik.Style()
    r = mapnik.Rule()
    sym = mapnik.PolygonSymbolizer()
    sym.fill = expected_color
    sym.clip = False
    r.symbols.append(sym)
    s.rules.append(r)
    lyr = mapnik.Layer('Layer')
    lyr.datasource = ds
    lyr.styles.append('style')
    m = mapnik.Map(256, 256)
    m.background_color = mapnik.Color('black')
    m.append_style('style', s)
    m.layers.append(lyr)
    # 17/20864/45265.png
    m.zoom_to_box(
        mapnik.Box2d(-13658379.710221574, 6197514.253362091,
                     -13657768.213995293, 6198125.749588372))
    # works 15/5216/11316.png
    #m.zoom_to_box(mapnik.Box2d(-13658379.710221574,6195679.764683247,-13655933.72531645,6198125.749588372))
    im = mapnik.Image(256, 256)
    mapnik.render(m, im)
    eq_(im.get_pixel(128, 128), expected_color.packed())