m.background = mapnik.Color('steelblue')
# MAP 1 DUNIA
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#7FFF00')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Ari', s)
ds = mapnik.Shapefile(file="countries/ne_110m_admin_0_countries.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Ari')
m.layers.append(layer)
# BATAS AKHIR MAP 1 DUNIA
# MAP 2 Negara Afganistan
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#D2691E')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
import mapnik
m = mapnik.Map(1000,700)
m.background = mapnik.Color('green')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#ff0000')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Ari', s)
ds = mapnik.Shapefile(file="provinsi/INDONESIA_PROP.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Ari')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m,'provinsi.png', 'png')
print "rendered image to 'world.png'"
import mapnik
m = mapnik.Map(1280, 720)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#ffff00')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('Blue'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('YUSUF', s)
ds = mapnik.Shapefile(file="ne_110m_admin_0_countries.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('YUSUF')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'world.tif', 'tif')
print "rendered image to 'world.tif' "
def create_utfgrids(shppath, minzoom, maxzoom, outdir, fields=None, layernum=0):
ds = ogr.Open(shppath)
print
print "WARNING:"
print " This script assumes a polygon shapefile in spherical mercator projection."
print " If any of these assumptions are not true, don't count on the results!"
# TODO confirm polygons
# TODO confirm mercator
# TODO get layernum from command line
layer = ds.GetLayer(layernum)
bbox = layer.GetExtent()
mercator = globalmaptiles.GlobalMercator()
m = mapnik.Map(256,256)
# Since grids are `rendered` they need a style
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)
ds = mapnik.Shapefile(file=shppath)
mlayer = mapnik.Layer('poly')
mlayer.datasource = ds
mlayer.styles.append('My Style')
m.layers.append(mlayer)
if fields is None:
fields = mlayer.datasource.fields()
for tz in range(minzoom, maxzoom+1):
print " * Processing Zoom Level %s" % tz
tminx, tminy = mercator.MetersToTile( bbox[0], bbox[2], tz)
tmaxx, tmaxy = mercator.MetersToTile( bbox[1], bbox[3], tz)
for ty in range(tminy, tmaxy+1):
for tx in range(tminx, tmaxx+1):
output = os.path.join(outdir, str(tz), str(tx))
if not os.path.exists(output):
os.makedirs(output)
# Use top origin tile scheme (like OSM or GMaps)
# TODO support option for TMS bottom origin scheme (ie opt to not invert)
ymax = 1 << tz;
invert_ty = ymax - ty - 1;
tilefilename = os.path.join(output, "%s.json" % invert_ty) # ty for TMS bottom origin
tilebounds = mercator.TileBounds( tx, ty, tz)
#print tilefilename, tilebounds
box = mapnik.Box2d(*tilebounds)
m.zoom_to_box(box)
grid = mapnik.Grid(m.width,m.height)
mapnik.render_layer(m,grid,layer=0,fields=fields)
utfgrid = grid.encode('utf',resolution=4)
with open(tilefilename, 'w') as file:
file.write(json.dumps(utfgrid))
# Adapted from https://github.com/mapnik/mapnik/wiki/GettingStartedInPython
# with https://github.com/mapnik/mapnik/issues/3258 to work with current bindings
import mapnik
m = mapnik.Map(2048, 1024)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#f2eff9')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.fill = mapnik.Color('rgb(50%,50%,50%)')
line_symbolizer.opacity = 0.1
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
layer = mapnik.Layer('world')
layer.datasource = mapnik.Shapefile(file='ne_110m_admin_0_countries.shp')
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'world.png', 'png')
print("rendered image to 'world.png'")
# -*- coding: utf-8 -*-
print('=' * 40)
print(__file__)
from helper.textool import get_tmp_file
################################################################################
import mapnik
datasource = mapnik.Shapefile(file="/gdata/GSHHS_c.shp")
################################################################################
datasource = mapnik.Shapefile(file="/gdata/GSHHS_c.shp", encoding="latin1")
################################################################################
datasource = mapnik.SQLite(file="spalite.db", table="pcapital", geometry_field="geom", key_field="name")
# Script to add the roads and city outline to the mapnik map.
##################### The first part is from listing 11.9.
import mapnik
# Create the map object.
srs = "+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs"
m = mapnik.Map(800, 600, srs)
m.zoom_to_box(mapnik.Box2d(-90.3, 29.7, -89.5, 30.3))
# Create a layer from a shapefile.
tiger_fn = r'D:\osgeopy-data\Louisiana\tiger_la_water_CENSUS_2006'
tiger_shp = mapnik.Shapefile(file=tiger_fn)
tiger_lyr = mapnik.Layer('Tiger')
tiger_lyr.datasource = tiger_shp
# Create a polygon fill symbol.
water_color = mapnik.Color(165, 191, 221)
water_fill_sym = mapnik.PolygonSymbolizer(water_color)
# Create a symbology style and add it to the layer.
tiger_rule = mapnik.Rule()
tiger_rule.symbols.append(water_fill_sym)
tiger_style = mapnik.Style()
tiger_style.rules.append(tiger_rule)
m.append_style('tiger', tiger_style)
# Add the style and layer to the map.
tiger_lyr.styles.append('tiger')
def test_adding_datasource_to_layer():
map_string = '''<?xml version="1.0" encoding="utf-8"?>
<Map>
<Layer name="world_borders">
<StyleName>world_borders_style</StyleName>
<StyleName>point_style</StyleName>
<!-- leave datasource empty -->
<!--
<Datasource>
<Parameter name="file">../data/shp/world_merc.shp</Parameter>
<Parameter name="type">shape</Parameter>
</Datasource>
-->
</Layer>
</Map>
'''
m = mapnik.Map(256, 256)
try:
mapnik.load_map_from_string(m, map_string)
# validate it loaded fine
eq_(m.layers[0].styles[0], 'world_borders_style')
eq_(m.layers[0].styles[1], 'point_style')
eq_(len(m.layers), 1)
# also assign a variable reference to that layer
# below we will test that this variable references
# the same object that is attached to the map
lyr = m.layers[0]
# ensure that there was no datasource for the layer...
eq_(m.layers[0].datasource, None)
eq_(lyr.datasource, None)
# also note that since the srs was black it defaulted to wgs84
eq_(m.layers[0].srs,
'+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
eq_(lyr.srs, '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# now add a datasource one...
ds = mapnik.Shapefile(file='../data/shp/world_merc.shp')
m.layers[0].datasource = ds
# now ensure it is attached
eq_(m.layers[0].datasource.describe()['name'], "shape")
eq_(lyr.datasource.describe()['name'], "shape")
# and since we have now added a shapefile in spherical mercator, adjust the projection
lyr.srs = '+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
# test that assignment
eq_(
m.layers[0].srs,
'+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
)
eq_(
lyr.srs,
'+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
)
except RuntimeError, e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(e)
# point_sym.filename
# r.symbols.append(point_sym)
# basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[Point]'), 'DejaVu Sans Bold',9,mapnik.Color('red'))
# basinsLabels.halo_fill = mapnik.Color('yellow')
# basinsLabels.halo_radius = 2
# r.symbols.append(basinsLabels)
# point_sym = mapnik.PointSymbolizer()
# point_sym.allow_overlap = True
# r.symbols.append(point_sym)
# s.rules.append(r)
s.rules.append(r)
m.append_style('Mellyn', s)
ds = mapnik.Shapefile(file="INDONESIA_PROP.shp")
layer = mapnik.Layer('indonesia')
layer.datasource = ds
layer.styles.append('Mellyn')
m.layers.append(layer)
# s = mapnik.Style()
# r = mapnik.Rule()
# line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('red'),1)
# r.symbols.append(line_symbolizer)
# s.rules.append(r)
# point_sym = mapnik.PointSymbolizer()
# point_sym.allow_overlap = True
# point_sym = mapnik.MarkersSymbolizer()
import mapnik
m = mapnik.Map(1280, 720)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('White')
r.symbols.append(polygon_symbolizer)
s.rules.append(r)
m.append_style('Yoesril', s)
ds = mapnik.Shapefile(file="INDONESIA_PROP.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Yoesril')
m.layers.append(layer)
m.zoom_all()
s.rules.append(r)
point_sym = mapnik.MarkersSymbolizer()
point_sym.filename
s = mapnik.Style()
r = mapnik.Rule()
basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[point]'),
'DejaVu Sans Bold', 2,
mapnik.Color('black'))
basinsLabels.halo_fill = mapnik.Color('Yellow')
basinsLabels.halo_radius = 0.3
m.background = mapnik.Color('steelblue')
# MAP 1 DUNIA
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#7FFF00')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Bangkit', s)
ds = mapnik.Shapefile(file="countries/ne_110m_admin_0_countries.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Bangkit')
m.layers.append(layer)
# BATAS AKHIR MAP 1 DUNIA
# MAP 2 Negara Afrika
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#D2691E')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
r.symbols.append(polygon_symbolizer) #add symbolizer to rule
#to outline a polygon
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)')
line_symbolizer.stroke_width = 0.1
r.symbols.append(line_symbolizer) #add symbolizer to rule
#add rule to the style
s.rules.append(r)
#add style to map
m.append_style("My Style", s)
#create a datasource
datasource = mapnik.Shapefile(file='110m-admin-0-countries/ne_110m_admin_0_countries.shp')
#prints full coordinate bounds of the data
print(datasource.envelope())
#create a layer
layer = mapnik.Layer('world')
#attach datasource to layer
layer.datasource = datasource
#style must be appended to layer
layer.styles.append('My Style')
#append layer to map and zoom to extent of layer
m.layers.append(layer)
m.zoom_all()
def testMapnik():
#Help from Dane Springmeyer: https://gist.github.com/3438657
#print mapnik.mapnik_version_string()
#mapfile = '/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/vogtland_style_PC-version.xml'
mapfile = '/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/slippy_vogtland.xml'
imgx = 256
imgy = 256
#print dir(imgx)
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
print mapnik.scale_denominator(m, mapnik.Projection(m.srs).geographic)
m.zoom_all()
m.buffer_size = 128
print '*Number of Layers: ', m.layers.__len__()
for layer in m.layers.__iter__():
print layer.name
#print layer.datasource.params().get('type')
#print layer.name
#print layer.datasource
#print dir(layer.datasource)
#print dir(layer.datasource.envelope())
#print layer.datasource.envelope()
#print layer.datasource.params().as_dict()['type']
#print layer.datasource.envelope().minx
#print layer.datasource.envelope().width()
#desc = layer.datasource.params().as_dict()
#print desc
#print layer.srs
#print layer.datasource.envelope()[0]
#print dir(layer.datasource.features)
length = len(layer.datasource.all_features())
# if length < 10:
# print dir(layer.datasource.all_features())
# for feature in layer.datasource.all_features().__iter__():
# print dir(feature)
# for item in feature.iteritems():
# print item
# print dir(layer.datasource)
#print layer.datasource.fields()
#print '**Number of Styles: ',len(layer.styles)
for i in xrange(len(layer.styles)):
#print layer.styles[i]
style = m.find_style(layer.styles[i])
#print '***Number of Rules: ',len(style.rules)
# for rule in style.rules.__iter__():
# print rule.filter, rule.min_scale, rule.max_scale
# for j in xrange(len(rule.symbols)):
# symbol = rule.symbols[j]
# print symbol
# symbol_type = str(symbol).split('.')[2].split(' ')[0]
# #print symbol_type
# if symbol_type == 'PolygonSymbolizer':
# help = 0
# #print symbol.fill, symbol.fill_opacity, symbol.gamma
# elif symbol_type == 'LineSymbolizer':
# stroke = symbol.stroke
# #print stroke.color, stroke.dash_offset, stroke.gamma, stroke.line_cap, stroke.line_join, stroke.opacity, stroke.width
## else:
# print 'Please implement the missing types!!!!!'
##print mapnik.save_map_to_string(m)
for plugs in mapnik.DatasourceCache.plugin_names():
plug_in = ''
for i in xrange(plugs.__len__()):
plug_in = plug_in + plugs.__getitem__(i)
#print plug_in
ds = mapnik.Shapefile(
file=
'/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/lines.shp'
)
poly_sym = mapnik.PolygonSymbolizer(poly_color)
# create a rule and add symbolizer to it
rule = mapnik.Rule()
rule.symbols.append(poly_sym)
# create a style and add rule to it
style = mapnik.Style()
style.rules.append(rule)
# add style to map as "MyStyle"
_map.append_style('MyStyle', style)
# get the shapefile
input_file = mapnik.Shapefile(
file=
'/home/preet/Documents/maps/shapefiles/coastline/osm_mar2013_full/land_polygons.shp'
)
# create a layer and add shapefile and style
layer = mapnik.Layer('world')
layer.datasource = input_file
layer.styles.append('MyStyle')
# add layer to map
_map.layers.append(layer)
###
FILE_PATH = './tiles/'
if not os.path.exists(FILE_PATH):
os.makedirs(FILE_PATH)
import mapnik
m = mapnik.Map(1080, 800)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#FF7F00')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('blue'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Heri', s)
ds = mapnik.Shapefile(file="shp kebun/lu_kebun.shp")
layer = mapnik.Layer('kebun')
layer.datasource = ds
layer.styles.append('Heri')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'kebun.png', 'png')
print "rendered image to 'world.png'"
""" mapnik_example.py
This is a minimal example of using Mapnik from Python. It is intended to
be read as part of the "A taste of Mapnik" section of Chapter 4 of the book
Python Geospatial Analysis.
"""
import mapnik
map = mapnik.Map(1200, 600)
map.background = mapnik.Color("#e0e0ff")
layer = mapnik.Layer("countries")
layer.datasource = mapnik.Shapefile(file="TM_WORLD_BORDERS-0.3/" +
"TM_WORLD_BORDERS-0.3.shp")
layer.styles.append("country_style")
map.layers.append(layer)
fill_symbol = mapnik.PolygonSymbolizer(mapnik.Color("#60a060"))
line_symbol = mapnik.LineSymbolizer(mapnik.Color("black"), 0.5)
rule = mapnik.Rule()
rule.symbols.append(fill_symbol)
rule.symbols.append(line_symbol)
style = mapnik.Style()
style.rules.append(rule)
map.append_style("country_style", style)
map.zoom_all()
import mapnik
m = mapnik.Map(1000, 700)
m.background = mapnik.Color('white')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#ff0000')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Ari', s)
ds = mapnik.Shapefile(file="sungai/IND_SNG_polyline.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Ari')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'sungai.png', 'png')
print "rendered image to 'world.png'"
import mapnik
m = mapnik.Map(600, 300)
m.background = mapnik.Color('red')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#fdf704')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Sancaka', s)
ds = mapnik.Shapefile(file="petaindonesia/map.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Sancaka')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'petaindonesia.jpeg', 'jpeg')
print "rendered image to 'petaindonesia.jpeg'"
m = mapnik.Map(
1000, 1000, '+init=epsg:4326'
) # create a map with a given width and height in pixels and projected in WGS 84.
m.background = mapnik.Color('#87CEFF') # set background colour.
ssStyles = mapnik.Style() # style object to hold rules for Study Site
ssRules = mapnik.Rule() # rule object to hold symbolizers for Study Site
citiesStyles = mapnik.Style() # style object to hold rules for Cities
citiesRules = mapnik.Rule() # rule object to hold symbolizers Cities
pStyles = mapnik.Style() # style object to hold rules for Peru
pRules = mapnik.Rule() # rule object to hold symbolizers Peru
studySiteDS = mapnik.Shapefile(file='StudySiteRegion.shp')
studySiteLyr = mapnik.Layer('Study Site', '+init=epsg:4326')
studySiteLyr.datasource = studySiteDS
peruDS = mapnik.Shapefile(file='GRC_adm1.shp')
peruLyr = mapnik.Layer('Peru', '+init=epsg:4326')
peruLyr.datasource = peruDS
cityNames = mapnik.Shapefile(file='places.shp')
citiesLyr = mapnik.Layer('Cities', '+init=epsg:4326')
citiesLyr.datasource = cityNames
#point_symbolizer_cities = mapnik.PointSymbolizer()#mapnik.Color('#000000'))
#citiesRules.symbols.append(point_symbolizer_cities)
t = mapnik.TextSymbolizer(mapnik.Expression('[name]'), 'DejaVu Sans Book', 12,
polygon_symbolizer.fill = mapnik.Color('#fdf704')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[NAME]'),
'DejaVu Sans Bold', 5,
mapnik.Color('black'))
basinsLabels.halo_fill = mapnik.Color('yellow')
basinsLabels.halo_radius = 2
r.symbols.append(basinsLabels)
point_sym = mapnik.PointSysmbolyzer()
point_sym.allow_overlap = TRUE
r.symbols.append(point_sym)
s.rules.append(r)
m.append_style('Yogi', s)
ds = mapnik.Shapefile(file="provinsiindonesia/INDONESIA_PROP.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Yogi')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, '1.png', 'png')
print "rendered image to '1.png'"
# type='shape'
# file='/path/to/shape'
# raster:
# type='raster'
# file='/path/to/raster'
# postgis:
# type='postgis'
# host='127.0.0.1'
# dbname='mydatabase'
# user='******'
# password='******'
# table= TODO
provpoly_lyr = mapnik.Layer('Provinces')
provpoly_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
provpoly_lyr.datasource = mapnik.Shapefile(file='../data/boundaries',
encoding='latin1')
# We then define a style for the layer. A layer can have one or many styles.
# Styles are named, so they can be shared across different layers.
# Multiple styles per layer behaves functionally like multiple layers. The
# data is completely re-scanned for each style within one layer, and a style
# will be drawn entirely "above" the previous one. Performance wise using
# multiple styles in one layer is the same has having multiple layers.
# The paradigm is useful mostly as a convenience.
provpoly_style = mapnik.Style()
# A Style needs one or more rules. A rule will normally consist of a filter
# for feature selection, and one or more symbolizers.
provpoly_rule_on = mapnik.Rule()
color = '#FFFFFF'
outline_color = '#000000'
rule = mapnik.Rule()
rule.filter = mapnik.Filter(the_filter)
symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(color))
rule.symbols.append(symbolizer)
precinct_style.rules.append(rule)
symbolizer = mapnik.LineSymbolizer()
symbolizer.stroke = mapnik.Stroke(mapnik.Color(outline_color), 1)
rule.symbols.append(symbolizer)
precinct_style.rules.append(rule)
layer1 = mapnik.Layer("Precinct Layer")
layer1.datasource = mapnik.Shapefile(file="data/Voter_Precinct.shp")
layer1.styles.append("Map Style")
columbia_pike_area = [201, 323, 324, 325, 326, 327, 331, 332, 334]
columbia_pike_area += [335, 338, 376, 457, 466, 467]
for roads in columbia_pike_area:
the_filter = '[OBJECTID] = {0}'.format(roads)
rule = mapnik.Rule()
rule.filter = mapnik.Filter(the_filter)
symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#FF7700'))
rule.symbols.append(symbolizer)
roads_style.rules.append(rule)
symbolizer = mapnik.LineSymbolizer()
#!/usr/bin/env python
import mapnik
m = mapnik.Map(800,600,"+proj=latlong +datum=WGS84")
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r=mapnik.Rule()
r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9')))
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1))
s.rules.append(r)
m.append_style('My Style',s)
lyr = mapnik.Layer('world',"+proj=latlong +datum=WGS84")
lyr.datasource = mapnik.Shapefile(file='world_borders')
lyr.styles.append('My Style')
m.layers.append(lyr)
m.zoom_to_box(lyr.envelope())
mapnik.render_to_file(m,'world_800x600.png', 'png')
# -*- coding: utf-8 -*-
print('=' * 40)
print(__file__)
from helper.textool import get_tmp_file
################################################################################
import mapnik
ds = mapnik.Shapefile(file='/gdata/GSHHS_c.shp')
ds.envelope()
################################################################################
import os
stylesheet = '/gdata/world_map.xml'
m = mapnik.Map(600, 300)
mapnik.load_map(m, stylesheet)
for x in m.layers:
print(x.name)
print(x.envelope())
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###############################################################################
###############################################################################
import os
import mapnik
m = mapnik.Map(1000, 800, '+init=epsg:4326')
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#f2eff9')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)')
line_symbolizer.stroke_width = 0.1
r.symbols.append(line_symbolizer)
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')
lyr.styles.append('My Style')
m.layers.append(lyr)
m.zoom_to_box(lyr.envelope())
mapnik.render_to_file(m, 'xx_b.png', 'png')
r2 = mapnik.Rule()
r.symbols.append(polygon_symbolizer)
r2.symbols.append(polygon_symbolizer2)
r.filter = mapnik.Expression("[id] = 1")
r2.filter = mapnik.Expression("[id] = 2")
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)')
line_symbolizer.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
line_symbolizer.stroke_width = 5.0
r.symbols.append(line_symbolizer)
r2.symbols.append(line_symbolizer)
s.rules.append(r)
s.rules.append(r2)
m.append_style('My Style', s)
lyr = mapnik.Layer('world', "+proj=latlong +datum=WGS84")
lyr.datasource = mapnik.Shapefile(file='/gdata/fig_data/fig_data_poly.shp')
lyr.styles.append('My Style')
m.layers.append(lyr)
m.zoom_all()
mapnik.render_to_file(m, 'xx_mapnik_filter.png', 'png')
###############################################################################
###############################################################################
###############################################################################
###############################################################################
r3 = mapnik.Rule()
r3.set_else(True)
r3.symbols.append(line_symbolizer)
s.rules.append(r3)
m.append_style('My Style2', s)
# create a rule and add symbolizer to it
vRule = mapnik.Rule()
vRule.symbols.append(vPolySym)
# create a style and add rule to it
vStyle = mapnik.Style()
vStyle.rules.append(vRule)
# add style to map as "MyStyle"
vMap.append_style('MyStyle', vStyle)
#vMap.append_style('TStyle',vTextStyle)
# get the shapefile
vFile = mapnik.Shapefile(
file='/home/preet/Documents/maps/shapefiles/coastline/osm_full/polygons.shp'
)
#vFile = mapnik.Shapefile(file='/home/preet/Documents/maps/shapefiles/coastline/ned_coast/ne_50m_coastline.shp')
# create a layer and add shapefile and style
vLayer = mapnik.Layer('world')
vLayer.datasource = vFile
vLayer.styles.append('MyStyle')
vLayer.styles.append('TStyle')
# add layer to map
vMap.layers.append(vLayer)
# zoom to bounds
vMap.zoom_all()
# Script demonstrating how to use multiple rules in a mapnik style.
##################### The first part is from listing 11.8.
import mapnik
# Create the map object.
srs = "+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs"
m = mapnik.Map(800, 600, srs)
m.zoom_to_box(mapnik.Box2d(-90.3, 29.7, -89.5, 30.3))
# Create a layer from a shapefile.
tiger_fn = r'D:\osgeopy-data\Louisiana\tiger_la_water_CENSUS_2006'
tiger_shp = mapnik.Shapefile(file=tiger_fn)
tiger_lyr = mapnik.Layer('Tiger')
tiger_lyr.datasource = tiger_shp
# Create a polygon fill symbol.
water_color = mapnik.Color(165, 191, 221)
water_fill_sym = mapnik.PolygonSymbolizer(water_color)
# Create a symbology style and add it to the layer.
tiger_rule = mapnik.Rule()
tiger_rule.symbols.append(water_fill_sym)
tiger_style = mapnik.Style()
tiger_style.rules.append(tiger_rule)
m.append_style('tiger', tiger_style)
# Add the style and layer to the map.
tiger_lyr.styles.append('tiger')
def test_total_feature_count_shp():
if 'shape' in mapnik.DatasourceCache.plugin_names():
ds = mapnik.Shapefile(file='../data/shp/poly.shp')
features = ds.all_features()
num_feats = len(features)
eq_(num_feats, 10)
def test_shapefile_point_zm_from_arcgis():
ds = mapnik.Shapefile(file='../data/shp/points/poi.shp')
eq_(len(ds.fields()),7)
eq_(ds.fields(),['interst_id', 'state_d', 'cnty_name', 'latitude', 'longitude', 'Name', 'Website'])
eq_(ds.field_types(),['str', 'str', 'str', 'float', 'float', 'str', 'str'])
eq_(len(ds.all_features()),17)
