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('green')
r.symbols.append(polygon_symbolizer)
s.rules.append(r)
m.append_style('Bangkit', s)
ds = mapnik.Shapefile(file="propinsi/INDONESIA_PROP.shp")
layer = mapnik.Layer('indonesia')
layer.datasource = ds
layer.styles.append('Bangkit')
m.layers.append(layer)
#test
s = mapnik.Style()
r = mapnik.Rule()
basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[nama]'),
'DejaVu Sans Bold', 3,
mapnik.Color('red'))
basinsLabels.halo_fill = mapnik.Color('yellow')
basinsLabels.halo_radius = 1
r.symbols.append(basinsLabels)
point_sym = mapnik.PointSymbolizer()
def map_render(map_id):
m = mapnik.Map(1920, 1080)
m.background = mapnik.Color('steelblue')
dbname = settings.DATABASES['default']['NAME']
user = settings.DATABASES['default']['USER']
password = settings.DATABASES['default']['PASSWORD']
params = dict(
dbname=dbname,
table='(select * from test_task_2_testfields where field_id=' +
str(map_id) + ') as query',
user=user,
password=password)
postgis = mapnik.PostGIS(**params)
lyr = mapnik.Layer('PostGis Layer')
lyr.datasource = postgis
######## main style
main_rule = mapnik.Rule()
main_style = mapnik.Style()
main_style.rules.append(main_rule)
m.append_style('main', main_style)
######### red style for productivi <= 30
red_filter = mapnik.Filter("[productivi] <= 30")
red_style = mapnik.Style()
red_rule = mapnik.Rule()
red_rule.filter = red_filter
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#FF0000')
red_rule.symbols.append(polygon_symbolizer)
red_style.rules.append(red_rule)
m.append_style('red', red_style)
# orange style for productivi >= 31 and < 70
orange_filter = mapnik.Filter(
"([productivi] > 30) and ([productivi] < 70)")
orange_style = mapnik.Style()
orange_rule = mapnik.Rule()
orange_rule.filter = orange_filter
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#FF8000')
orange_rule.symbols.append(polygon_symbolizer)
orange_style.rules.append(orange_rule)
m.append_style('orange', orange_style)
######## green style for productivi >+ 70
green_filter = mapnik.Filter("([productivi] >= 70)")
green_style = mapnik.Style()
green_rule = mapnik.Rule()
green_rule.filter = green_filter
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#00FF00')
green_rule.symbols.append(polygon_symbolizer)
green_style.rules.append(green_rule)
m.append_style('green', green_style)
######## render
lyr.styles.append('main')
lyr.styles.append('red')
lyr.styles.append('orange')
lyr.styles.append('green')
m.layers.append(lyr)
m.zoom_all()
if not os.path.exists('media/Map'):
os.makedirs('media/Map')
mapnik.render_to_file(m, 'media/Map/map.png', 'png')
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#f2eff9')
rule.symbols.append(polygon_symbolizer)
# Create a LineSymbolizer to style the polygons borders and add it to the rule
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(50%, 50%, 50%)')
line_symbolizer.stroke_width = 0.1
rule.symbols.append(line_symbolizer)
# Add the rule to the style
style.rules.append(rule)
# Add the style to the map
map.append_style('My Style', style)
# Create a data source from a shapefile
data = mapnik.Shapefile(file='../../data/world_borders_simple.shp')
# Create a layer giving it the name 'world'
layer = mapnik.Layer('world')
# Set the layer data source and add the style to the layer
layer.datasource = data
layer.styles.append('My Style')
# Add the layer to the map
map.layers.append(layer)
# Zoom the map to the extent of all layers
map.zoom_all()
# Write the map to an image
mapnik.render_to_file(map, '../output/world_python.png', 'png')
def _test_grayscale_subquery(lbl, pixtype, value):
#
# 3 8 13
# +---+---+---+
# 3 | v | v | v | NOTE: writes different color
# +---+---+---+ in 13,8 and 8,13
# 8 | v | v | a |
# +---+---+---+
# 13 | v | b | v |
# +---+---+---+
#
val_a = int(value / 3)
val_b = val_a * 2
sql = "(select 3 as i, " \
" ST_SetValues(" \
" ST_SetValues(" \
" ST_AsRaster(" \
" ST_MakeEnvelope(0,0,14,14), " \
" 1.0, -1.0, '%s', %s" \
" ), " \
" 11, 6, 4, 5, %s::float8" \
" )," \
" 6, 11, 5, 4, %s::float8" \
" ) as \"R\"" \
") as foo" % (pixtype, value, val_a, val_b)
rescale = 0
clip = 0
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=sql,
raster_field='"R"',
use_overviews=1,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['i'], 3)
lyr = mapnik.Layer('grayscale_subquery')
lyr.datasource = ds
expenv = mapnik.Box2d(0, 0, 14, 14)
env = lyr.envelope()
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, places=0)
assert_almost_equal(env.maxx, expenv.maxx, places=0)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(15, 15)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s.png' % (lyr.name, lbl,
pixtype, value)
compare_images(expected, im)
h = format(value, '02x')
hex_v = h + h + h + 'ff'
hex_v = hex_v.encode()
h = format(val_a, '02x')
hex_a = h + h + h + 'ff'
hex_a = hex_a.encode()
h = format(val_b, '02x')
hex_b = h + h + h + 'ff'
hex_b = hex_b.encode()
eq_(hexlify(im.view(3, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(3, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 8, 1, 1).tostring()), hex_a)
eq_(hexlify(im.view(3, 13, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 13, 1, 1).tostring()), hex_b)
eq_(hexlify(im.view(13, 13, 1, 1).tostring()), hex_v)
def _test_rgba_subquery(lbl, pixtype, r, g, b, a, g1, b1):
#
# 3 8 13
# +---+---+---+
# 3 | v | v | h | NOTE: writes different alpha
# +---+---+---+ in 13,8 and 8,13
# 8 | v | v | a |
# +---+---+---+
# 13 | v | b | v |
# +---+---+---+
#
sql = "(select 3 as i, " \
" ST_SetValues(" \
" ST_SetValues(" \
" ST_AddBand(" \
" ST_AddBand(" \
" ST_AddBand(" \
" ST_AsRaster(" \
" ST_MakeEnvelope(0,0,14,14), " \
" 1.0, -1.0, '%s', %s" \
" )," \
" '%s', %d::float" \
" ), " \
" '%s', %d::float" \
" ), " \
" '%s', %d::float" \
" ), " \
" 2, 11, 6, 4, 5, %s::float8" \
" )," \
" 3, 6, 11, 5, 4, %s::float8" \
" ) as r" \
") as foo" % (
pixtype,
r,
pixtype,
g,
pixtype,
b,
pixtype,
a,
g1,
b1)
overview = ''
rescale = 0
clip = 0
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=sql,
raster_field='r',
use_overviews=0 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['i'], 3)
lyr = mapnik.Layer('rgba_subquery')
lyr.datasource = ds
expenv = mapnik.Box2d(0, 0, 14, 14)
env = lyr.envelope()
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, places=0)
assert_almost_equal(env.maxx, expenv.maxx, places=0)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(15, 15)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-%s-%s-%s-%s.png' % (
lyr.name, lbl, pixtype, r, g, b, a, g1, b1)
compare_images(expected, im)
hex_v = format(r << 24 | g << 16 | b << 8 | a, '08x').encode()
hex_a = format(r << 24 | g1 << 16 | b << 8 | a, '08x').encode()
hex_b = format(r << 24 | g << 16 | b1 << 8 | a, '08x').encode()
eq_(hexlify(im.view(3, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(3, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 8, 1, 1).tostring()), hex_a)
eq_(hexlify(im.view(3, 13, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 13, 1, 1).tostring()), hex_b)
eq_(hexlify(im.view(13, 13, 1, 1).tostring()), hex_v)
s = mapnik.Style()
r = mapnik.Rule()
point_sym = mapnik.PointSymbolizer()
point_sym.filename = './symbols/airport.p.16.png'
r.symbols.append(point_sym) # add the symbolizer to the rule object
s.rules.append(r) # now add the rule to the style and we're done
m.append_style('airport point', s)
#add your data source.. usually would be a PostgreSQL/SQLite database
ds = mapnik.MemoryDatasource()
f = mapnik.Feature(mapnik.Context(), 1)
f.add_geometries_from_wkt("POINT(-92.289595 34.746481)")
ds.add_feature(f)
#create the layer and add the data
player = mapnik.Layer('airport_layer')
player.srs = longlat.params()
player.datasource = ds
player.styles.append('airport point')
m.layers.append(player)
m.zoom_all()
if hasattr(mapnik, 'Box2d'):
bbox = mapnik.Box2d(*bounds)
else:
bbox = mapnik.Envelope(*bounds)
# Our bounds above are in long/lat, but our map
# is in spherical mercator, so we need to transform
# the bounding box to mercator to properly position
# the Map when we call `zoom_to_box()`
def _test_rgba_8bui_rendering(lbl, overview, rescale, clip):
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table='(select * from "River") foo',
use_overviews=1 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['rid'], 1)
lyr = mapnik.Layer('rgba_8bui')
lyr.datasource = ds
expenv = mapnik.Box2d(0, -210, 256, 0)
env = lyr.envelope()
# As the input size is a prime number both horizontally
# and vertically, we expect the extent of the overview
# tables to be a pixel wider than the original, whereas
# the pixel size in geographical units depends on the
# overview factor. So we start with the original pixel size
# as base scale and multiply by the overview factor.
# NOTE: the overview table extent only grows north and east
pixsize = 1 # see gdalinfo river.tif
tol = pixsize * max(overview.split(',')) if overview else 0
assert_almost_equal(env.minx, expenv.minx)
assert_almost_equal(env.miny, expenv.miny, delta=tol)
assert_almost_equal(env.maxx, expenv.maxx, delta=tol)
assert_almost_equal(env.maxy, expenv.maxy)
mm = mapnik.Map(256, 256)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-box1.png' % (
lyr.name, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 3, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(250, 250, 1, 1).tostring()), b'00000000')
# full opaque river color
eq_(hexlify(im.view(175, 118, 1, 1).tostring()), b'b9d8f8ff')
# half-transparent pixel
pxstr = hexlify(im.view(122, 138, 1, 1).tostring()).decode()
apat = ".*(..)$"
match = re.match(apat, pxstr)
assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat
alpha = match.group(1)
assert alpha != 'ff' and alpha != '00', \
'unexpected full transparent/opaque pixel: ' + alpha
# Now zoom over a portion of the env (1/10)
newenv = mapnik.Box2d(166, -105, 191, -77)
mm.zoom_to_box(newenv)
t0 = time.time() # we want wall time to include IO waits
im = mapnik.Image(mm.width, mm.height)
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10')
expected = 'images/support/pgraster/%s-%s-%s-%s-box2.png' % (
lyr.name, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(255, 255, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(200, 40, 1, 1).tostring()), b'00000000')
# full opaque river color
eq_(hexlify(im.view(100, 168, 1, 1).tostring()), b'b9d8f8ff')
# half-transparent pixel
pxstr = hexlify(im.view(122, 138, 1, 1).tostring()).decode()
apat = ".*(..)$"
match = re.match(apat, pxstr)
assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat
alpha = match.group(1)
assert alpha != 'ff' and alpha != '00', \
'unexpected full transparent/opaque pixel: ' + alpha
# Allow Overlaps and set opacity of marker
point_symbolizer.allow_overlap = True
point_symbolizer.opacity = 0.7
# add the point_symbolizer to the rule object
r.symbols.append(point_symbolizer)
# now add the rule(s) to the style
s.rules.append(r)
# Styles are added to the map
m.append_style('My Style', s)
# Projection from PostGIS-Layer-Data
lyr = mapnik.Layer(
'Geometry from PostGIS',
'+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'
)
# PostGIS-Connection + DB-Query
lyr.datasource = mapnik2.PostGIS(host=hostname,
user=db_user,
password=db_pw,
dbname=db_name,
table=db_query)
# Append Style to layer
lyr.styles.append('My Style')
#
# END Layer 1
#
def getMapImage(osmFile, map_output):
'''Uses the data from the osmFile to out a .png image
of the area depicted by the input file'''
if not HAS_MAPNIK:
print('Error: Mapnik module is missing. ' +
'Please install for getting the image functionality.')
return -2
print('Has Mapnik.')
if osmFile == '':
print
'Error: getMapImage::No File Recieved'
return -1
else:
print('OSM File: ' + osmFile)
highwayList = dict({
"motorway": {
'width': 4,
'color': 'green',
'fontSize': 12
},
"trunk": {
'width': 3,
'color': 'green',
'fontSize': 11
},
"primary": {
'width': 1.5,
'color': '#0090ff',
'fontSize': 10
},
"secondary": {
'width': 0.8,
'color': '#ff00ff',
'fontSize': 8
},
"tertiary": {
'width': 0.42,
'color': '#000000',
'fontSize': 8
},
"residential": {
'width': 0.21,
'color': 'black',
'fontSize': 8
},
"living_street": {
'width': 0.21,
'color': 'black',
'fontSize': 8
},
"pedestrian": {
'width': 0.21,
'color': 'brown',
'fontSize': 8
},
"footway": {
'width': 0.21,
'color': 'brown',
'fontSize': 8
}
})
m = mapnik.Map(1024, 1024)
m.background = mapnik.Color('white')
for highwayType in highwayList.keys():
styleType = mapnik.Style()
print(styleType)
rule = mapnik.Rule()
rule.filter = mapnik.Expression('[highway]=' + "'" + highwayType + "'")
stk = mapnik.Stroke()
stk.color = mapnik.Color(highwayList[highwayType]['color'])
stk.line_cap = mapnik.line_cap.ROUND_CAP
stk.width = highwayList[highwayType]['width']
line_symbolizer = mapnik.LineSymbolizer(stk)
rule.symbols.append(line_symbolizer)
rule2 = mapnik.Rule()
rule2.filter = mapnik.Expression('[highway]=' + "'" + highwayType +
"'")
text_symbolizer = mapnik.TextSymbolizer(
mapnik.Expression("[name]"), "DejaVu Sans Book",
highwayList[highwayType]['fontSize'], mapnik.Color('black'))
text_symbolizer.halo_fill = mapnik.Color('white')
rule2.symbols.append(text_symbolizer)
styleType.rules.append(rule)
styleType.rules.append(rule2)
m.append_style(highwayType, styleType)
ds = mapnik.Osm(file=osmFile)
layer = mapnik.Layer('world')
layer.datasource = ds
for highwayType in highwayList.keys():
layer.styles.append(highwayType)
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, map_output, 'png')
return os.system('xdg-open ' + map_output)
# Script to create an xml file to describe the National Atlas
# hydrography layer.
import mapnik
m = mapnik.Map(0, 0)
water_rule = mapnik.Rule()
water_rule.filter = mapnik.Expression("[Feature]='Canal' or [Feature]='Lake'")
water_rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color(165, 191,
221)))
marsh_rule = mapnik.Rule()
marsh_rule.filter = mapnik.Expression("[Feature]='Swamp or Marsh'")
marsh_color = mapnik.Color('#66AA66')
marsh_rule.symbols.append(mapnik.PolygonSymbolizer(marsh_color))
marsh_rule.symbols.append(mapnik.LineSymbolizer(marsh_color, 2))
atlas_style = mapnik.Style()
atlas_style.rules.append(water_rule)
atlas_style.rules.append(marsh_rule)
m.append_style('atlas', atlas_style)
lyr = mapnik.Layer('National Atlas Hydro',
"+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs")
lyr.datasource = mapnik.Shapefile(file=r'D:\osgeopy-data\US\wtrbdyp010')
lyr.styles.append('atlas')
m.layers.append(lyr)
mapnik.save_map(m, r'D:\osgeopy-data\US\national_atlas_hydro.xml')
# Script demonstrating how to use multiple rules in a mapnik style.
##################### The first part is from listing 13.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')
# create a style
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)
# add style to map
m.append_style('My Style', s)
# create datasource
ds = mapnik.Shapefile(file='../data/TM_WORLD_BORDERS-0.3.shp')
# create a layer
layer = mapnik.Layer('world') # a new layer called world
layer.datasource = ds
layer.styles.append('My Style')
# render map
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'world.png', 'png')
for country in countryList.findall("country"):
name = country.find("name").text
iso3 = country.find("iso3").text
logging.info("Processing %s" % name)
# Create Datasource
query = '(SELECT * FROM GAUL_2010_2 WHERE ISO3 = "%s")' % iso3
datasource = mapnik.SQLite(file=dbPath,
table=query,
geometry_field="Geometry",
key_field="PK_UID",
use_spatial_index=False)
# Create layer
layer = mapnik.Layer("boundaries")
layer.datasource = datasource
layer.styles.append("boundariesStyle")
# Calculate image output size
envelope = datasource.envelope()
dLong = envelope.maxx - envelope.minx
dLat = envelope.maxy - envelope.miny
aspectRatio = dLong / dLat
if dLong > dLat:
width = max_img_size
height = int(width / aspectRatio)
elif dLat > dLong:
height = max_img_size
width = int(aspectRatio * height)
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')
#JAPAN ADMINISTRATIVE
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#a0a0a0')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('yellow'), 5)
line_symbolizer.stroke_width = 50.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style1', s)
ds = mapnik.Shapefile(file="JPN_adm/JPN_adm0.shp")
layer = mapnik.Layer('jpn_adm')
layer.datasource = ds
layer.styles.append('My Style1')
m.layers.append(layer)
#JAPAN ADMINISTRATIVE 2
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#d9d9d9')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1)
r.symbols.append(line_symbolizer)
s.rules.append(r)
def tile(request, version, shapefile_id, zoom, x, y):
shapefile = None
try:
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = xExtent * x - 180.0
minLat = yExtent * y - 90.0
maxLong = minLong + xExtent
maxLat = minLat + xExtent
#if (minLong < -180 or maxLong > 180 or
#minLat < -90 or maxLat > 90):
#raise Http404
map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT, "+proj=longlat +datum=WGS84")
map.background = mapnik.Color("#7391ad")
dbSettings = settings.DATABASES['default']
datasource = mapnik.PostGIS(host='localhost',
user='******',
password='******',
dbname='spatial',
table='"shapeEditor_basemap"',
srid=4326,
geometry_field="geometry",
geometry_table='"shapeEditor_basemap"')
baseLayer = mapnik.Layer("baseLayer")
baseLayer.datasource = datasource
baseLayer.styles.append("baseLayerStyle")
rule = mapnik.Rule()
rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c")))
rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color("#000000"),
0.1))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("baseLayerStyle", style)
map.layers.append(baseLayer)
geometryField = utils.calcGeometryField(shapefile.geom_type)
query = '(select ' + geometryField + ' from "shapeEditor_feature" where' + ' shapefile_id=' + str(
shapefile.id) + ') as geom'
datasource = mapnik.PostGIS(host='localhost',
user='******',
password='******',
dbname='spatial',
table=query,
srid=4326,
geometry_field=geometryField,
geometry_table='"shapeEditor_feature"')
featureLayer = mapnik.Layer("featureLayer")
featureLayer.datasource = datasource
featureLayer.styles.append("featureLayerStyle")
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("#f7edee")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("featureLayerStyle", style)
map.layers.append(featureLayer)
map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat))
image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik.render(map, image)
imageData = image.tostring('png')
return HttpResponse(imageData, content_type="image/png")
except:
traceback.print_exc()
return HttpResponse("")
r.symbols.append(text_sym)
point_sym = mapnik.PointSymbolizer()
point_sym.allow_overlap = True
r.symbols.append(point_sym)
s.rules.append(r)
m.append_style("airport point", s)
ds = mapnik.MemoryDatasource()
f = mapnik.Feature(mapnik.Context(), 1)
#f["NAME"] = "JUANDA"
f.add_geometries_from_wkt("POINT(-7.3788851 112.7851004)")
ds.add_feature(f)
player = mapnik.Layer("airport_layer")
player.datasource = ds
player.styles.append("airport point")
m.layers.append(player)
m.append_style('My Style', s)
ds = mapnik.Shapefile(file="SHP_Indonesia_provinsi/INDONESIA_PROP.shp")
layer = mapnik.Layer('propinsi')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'T5_Muhammad-Habibi_04315004-point.pdf', 'pdf')
print "rendered image to 'T5_Muhammad-Habibi_04315004-point.png' "
import os.path
import mapnik
symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("darkgreen"))
rule = mapnik.Rule()
rule.symbols.append(symbolizer)
style = mapnik.Style()
style.rules.append(rule)
layer = mapnik.Layer("mapLayer")
layer.datasource = mapnik.Shapefile(file="TM_WORLD_BORDERS-0.3.shp")
layer.styles.append("mapStyle")
map = mapnik.Map(800, 400)
map.background = mapnik.Color("steelblue")
map.append_style("mapStyle", style)
map.layers.append(layer)
map.zoom_all()
mapnik.render_to_file(map, "map.png", "png")
def _test_dataraster_16bsi_rendering(lbl, overview, rescale, clip):
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table='"dataRaster"',
band=1,
use_overviews=1 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['rid'], 1)
lyr = mapnik.Layer('dataraster_16bsi')
lyr.datasource = ds
expenv = mapnik.Box2d(-14637, 3903178, 1126863, 4859678)
env = lyr.envelope()
# As the input size is a prime number both horizontally
# and vertically, we expect the extent of the overview
# tables to be a pixel wider than the original, whereas
# the pixel size in geographical units depends on the
# overview factor. So we start with the original pixel size
# as base scale and multiply by the overview factor.
# NOTE: the overview table extent only grows north and east
pixsize = 500 # see gdalinfo dataraster.tif
pixsize = 2497 # see gdalinfo dataraster-small.tif
tol = pixsize * max(overview.split(',')) if overview else 0
assert_almost_equal(env.minx, expenv.minx)
assert_almost_equal(env.miny, expenv.miny, delta=tol)
assert_almost_equal(env.maxx, expenv.maxx, delta=tol)
assert_almost_equal(env.maxy, expenv.maxy)
mm = mapnik.Map(256, 256)
style = mapnik.Style()
col = mapnik.RasterColorizer()
col.default_mode = mapnik.COLORIZER_DISCRETE
col.add_stop(0, mapnik.Color(0x40, 0x40, 0x40, 255))
col.add_stop(10, mapnik.Color(0x80, 0x80, 0x80, 255))
col.add_stop(20, mapnik.Color(0xa0, 0xa0, 0xa0, 255))
sym = mapnik.RasterSymbolizer()
sym.colorizer = col
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
# no data
eq_(im.view(1, 1, 1, 1).tostring(), b'\x00\x00\x00\x00')
eq_(im.view(255, 255, 1, 1).tostring(), b'\x00\x00\x00\x00')
eq_(im.view(195, 116, 1, 1).tostring(), b'\x00\x00\x00\x00')
# A0A0A0
eq_(im.view(100, 120, 1, 1).tostring(), b'\xa0\xa0\xa0\xff')
eq_(im.view(75, 80, 1, 1).tostring(), b'\xa0\xa0\xa0\xff')
# 808080
eq_(im.view(74, 170, 1, 1).tostring(), b'\x80\x80\x80\xff')
eq_(im.view(30, 50, 1, 1).tostring(), b'\x80\x80\x80\xff')
# 404040
eq_(im.view(190, 70, 1, 1).tostring(), b'\x40\x40\x40\xff')
eq_(im.view(140, 170, 1, 1).tostring(), b'\x40\x40\x40\xff')
# Now zoom over a portion of the env (1/10)
newenv = mapnik.Box2d(273663, 4024478, 330738, 4072303)
mm.zoom_to_box(newenv)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10')
# nodata
eq_(hexlify(im.view(255, 255, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(200, 254, 1, 1).tostring()), b'00000000')
# A0A0A0
eq_(hexlify(im.view(90, 232, 1, 1).tostring()), b'a0a0a0ff')
eq_(hexlify(im.view(96, 245, 1, 1).tostring()), b'a0a0a0ff')
# 808080
eq_(hexlify(im.view(1, 1, 1, 1).tostring()), b'808080ff')
eq_(hexlify(im.view(128, 128, 1, 1).tostring()), b'808080ff')
# 404040
eq_(hexlify(im.view(255, 0, 1, 1).tostring()), b'404040ff')
# Script to add the roads and city outline to the mapnik map.
##################### The first part is from listing 13.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_rgb_8bui_rendering(lbl, tnam, overview, rescale, clip):
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=tnam,
use_overviews=1 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['rid'], 1)
lyr = mapnik.Layer('rgba_8bui')
lyr.datasource = ds
expenv = mapnik.Box2d(-12329035.7652168, 4508650.39854396,
-12328653.0279471, 4508957.34625536)
env = lyr.envelope()
# As the input size is a prime number both horizontally
# and vertically, we expect the extent of the overview
# tables to be a pixel wider than the original, whereas
# the pixel size in geographical units depends on the
# overview factor. So we start with the original pixel size
# as base scale and multiply by the overview factor.
# NOTE: the overview table extent only grows north and east
pixsize = 2 # see gdalinfo nodata-edge.tif
tol = pixsize * max(overview.split(',')) if overview else 0
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, delta=tol)
assert_almost_equal(env.maxx, expenv.maxx, delta=tol)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(256, 256)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box1.png' % (
lyr.name, tnam, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 16, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(128, 16, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(250, 16, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(3, 240, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(128, 240, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(250, 240, 1, 1).tostring()), b'00000000')
# dark brown
eq_(hexlify(im.view(174, 39, 1, 1).tostring()), b'c3a698ff')
# dark gray
eq_(hexlify(im.view(195, 132, 1, 1).tostring()), b'575f62ff')
# Now zoom over a portion of the env (1/10)
newenv = mapnik.Box2d(-12329035.7652168, 4508926.651484220,
-12328997.49148983, 4508957.34625536)
mm.zoom_to_box(newenv)
t0 = time.time() # we want wall time to include IO waits
im = mapnik.Image(mm.width, mm.height)
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box2.png' % (
lyr.name, tnam, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 16, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(128, 16, 1, 1).tostring()), b'00000000')
eq_(hexlify(im.view(250, 16, 1, 1).tostring()), b'00000000')
# black
eq_(hexlify(im.view(3, 42, 1, 1).tostring()), b'000000ff')
eq_(hexlify(im.view(3, 134, 1, 1).tostring()), b'000000ff')
eq_(hexlify(im.view(3, 244, 1, 1).tostring()), b'000000ff')
# gray
eq_(hexlify(im.view(135, 157, 1, 1).tostring()), b'4e555bff')
# brown
eq_(hexlify(im.view(195, 223, 1, 1).tostring()), b'f2cdbaff')
the_filter = '[PRECINCT] = {0}'.format(precinct)
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")
# Add another layer with a record from the Roads file
rule = mapnik.Rule()
rule.filter = mapnik.Filter('[OBJECTID] = 324')
symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#FF7700'))
rule.symbols.append(symbolizer)
roads_style.rules.append(rule)
symbolizer = mapnik.LineSymbolizer()
symbolizer.stroke = mapnik.Stroke(mapnik.Color('#FF7700'), 1)
rule.symbols.append(symbolizer)
roads_style.rules.append(rule)
def _test_data_subquery(lbl, pixtype, value):
#
# 3 8 13
# +---+---+---+
# 3 | v | v | v | NOTE: writes different values
# +---+---+---+ in 13,8 and 8,13
# 8 | v | v | a |
# +---+---+---+
# 13 | v | b | v |
# +---+---+---+
#
val_a = value / 3
val_b = val_a * 2
sql = "(select 3 as i, " \
" ST_SetValues(" \
" ST_SetValues(" \
" ST_AsRaster(" \
" ST_MakeEnvelope(0,0,14,14), " \
" 1.0, -1.0, '%s', %s" \
" ), " \
" 11, 6, 5, 5, %s::float8" \
" )," \
" 6, 11, 5, 5, %s::float8" \
" ) as \"R\"" \
") as foo" % (pixtype, value, val_a, val_b)
overview = ''
rescale = 0
clip = 0
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=sql,
raster_field='R',
use_overviews=0 if overview else 0,
band=1,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['i'], 3)
lyr = mapnik.Layer('data_subquery')
lyr.datasource = ds
expenv = mapnik.Box2d(0, 0, 14, 14)
env = lyr.envelope()
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, places=0)
assert_almost_equal(env.maxx, expenv.maxx, places=0)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(15, 15)
style = mapnik.Style()
col = mapnik.RasterColorizer()
col.default_mode = mapnik.COLORIZER_DISCRETE
col.add_stop(val_a, mapnik.Color(0xff, 0x00, 0x00, 255))
col.add_stop(val_b, mapnik.Color(0x00, 0xff, 0x00, 255))
col.add_stop(value, mapnik.Color(0x00, 0x00, 0xff, 255))
sym = mapnik.RasterSymbolizer()
sym.colorizer = col
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s.png' % (lyr.name, lbl,
pixtype, value)
compare_images(expected, im)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###############################################################################
import os
import mapnik
stylesheet = '/gdata/world_population.xml'
m = mapnik.Map(600, 300)
mapnik.load_map(m, stylesheet)
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)
s.rules.append(r)
m.append_style('My Style2', s)
###############################################################################
wkt_geom = 'POLYGON ((5 21,-18 -10, -16 -52, 37 -21, 5 21))'
csv_string = '''
wkt,Name
"{wkt_geom}","test"
'''.format(wkt_geom=wkt_geom)
ds = mapnik.Datasource(**{"type": "csv", "inline": csv_string})
layer2 = mapnik.Layer('world', '+proj=latlong +datum=WGS84')
layer2.datasource = ds
layer2.styles.append('My Style2')
m.layers.append(layer2)
m.zoom_all()
mapnik.render_to_file(m, 'xx_ds_pt.png', 'png')
def tile(request, version, shapefile_id, zoom, x, y):
try:
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = x * xExtent - 180.0
minLat = y * yExtent - 90.0
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -180 or maxLong > 180 or
minLat < -90 or maxLat > 90):
print "Map extent out of bounds:",minLong,minLat,maxLong,maxLat
raise Http404
#######################################################
map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT,
str("+proj=longlat +datum=WGS84"))
map.background = mapnik.Color(str("#7391ad"))
dbSettings = settings.DATABASES['default']
datasource = mapnik.PostGIS(user=str(dbSettings['USER']),password=str(dbSettings['PASSWORD']),
dbname=str(dbSettings['NAME']),table='tms_basemap', srid=4326,
geometry_field="geometry", geometry_table='tms_basemap',
port=5433)
baseLayer = mapnik.Layer(str("baseLayer"))
baseLayer.datasource = datasource
baseLayer.styles.append(str("baseLayerStyle"))
rule = mapnik.Rule()
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color(str("#b5d19c"))))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color(str("#404040")), 0.2))
style = mapnik.Style()
style.rules.append(rule)
map.append_style(str("baseLayerStyle"), style) ####
map.layers.append(baseLayer)
geometry_field = \
utils.calc_geometry_field(shapefile.geom_type)
query = '(SELECT ' + geometry_field \
+ ' FROM "shared_feature" WHERE' \
+ ' shapefile_id = ' + str(shapefile.id) + ') as geom'
print query
print dbSettings['USER'],dbSettings['PASSWORD'],dbSettings['NAME'],query,geometry_field
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
port=dbSettings['PORT'],
srid=4326,
table=query,
geometry_field=geometry_field,
geometry_table='shared_feature',
)
featureLayer = mapnik.Layer(str("featureLayer"))
featureLayer.datasource = datasource
featureLayer.styles.append(str("featureLayerStyle"))
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color(str("#f7edee"))))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color(str("#000000")), 0.5))
style = mapnik.Style()
style.rules.append(rule)
map.append_style(str("featureLayerStyle"), style)
map.layers.append(featureLayer)
map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat))
image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik.render(map, image)
imageData = image.tostring(str('png'))
print imageData
return HttpResponse(imageData, content_type="image/png")
except:
traceback.print_exc()
return HttpResponse("Error")
# Script to draw a topo map with a hillshade underneath.
import mapnik
srs = '+proj=utm +zone=10 +ellps=GRS80 +datum=NAD83 +units=m +no_defs'
m = mapnik.Map(1200, 1200, srs)
m.zoom_to_box(mapnik.Box2d(558800, 5112200, 566600, 5120500))
hillshade_lyr = mapnik.Layer('Hillshade', srs)
hillshade_raster = mapnik.Gdal(
file=r'D:\osgeopy-data\Washington\dem\sthelens_hillshade.tif')
hillshade_lyr.datasource = hillshade_raster
hillshade_rule = mapnik.Rule()
hillshade_rule.symbols.append(mapnik.RasterSymbolizer())
hillshade_style = mapnik.Style()
hillshade_style.rules.append(hillshade_rule)
m.append_style('hillshade', hillshade_style)
hillshade_lyr.styles.append('hillshade')
topo_lyr = mapnik.Layer('Topo', srs)
topo_raster = mapnik.Gdal(file=r'D:\osgeopy-data\Washington\dem\st_helens.tif')
topo_lyr.datasource = topo_raster
topo_sym = mapnik.RasterSymbolizer()
topo_sym.opacity = 0.6 #A
topo_rule = mapnik.Rule()
topo_rule.symbols.append(topo_sym)
topo_style = mapnik.Style()
topo_style.rules.append(topo_rule)
def map_image(zoom, left, bottom, right, top, line, orientation='n', highres=True):
mapfile = settings.MAPNIK_STYLES + "mapnik2normal.xml"
if orientation != 'n':
mapfile = settings.MAPNIK_STYLES + "mapnik2orlice_%s.xml" % str(orientation)
imgx, imgy = get_image_size(zoom, top, left, bottom, right)
if orientation in ('w', 'e'):
imgx, imgy = imgy, imgx
if highres:
mapfile = settings.MAPNIK_STYLES + "mapnik2print.xml"
if orientation != 'n':
mapfile = settings.MAPNIK_STYLES + "mapnik2print_orlice_%s.xml" % str(orientation)
imgx = 2*imgx
imgy = 2*imgy
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
prj = 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')
# North on top
n0 = prj.forward(mapnik.Coord(left, bottom))
n1 = prj.forward(mapnik.Coord(right, top))
# East on top
e0 = mapnik.Coord(-n0.y, n0.x)
e1 = mapnik.Coord(-n1.y, n1.x)
# South on top
s0 = mapnik.Coord(-n1.x, -n1.y)
s1 = mapnik.Coord(-n0.x, -n0.y)
# West on top
w0 = mapnik.Coord(-e1.x, -e1.y)
w1 = mapnik.Coord(-e0.x, -e0.y)
# bottom_left = prj.forward(mapnik.Coord(left, bottom))
# top_right = prj.forward(mapnik.Coord(right, top))
boxes = {'n': mapnik.Box2d(n0.x, n0.y, n1.x, n1.y),
'e': mapnik.Box2d(e0.x, e0.y, e1.x, e1.y),
's': mapnik.Box2d(s0.x, s0.y, s1.x, s1.y),
'w': mapnik.Box2d(w0.x, w0.y, w1.x, w1.y)
}
if line:
gpxstyle = mapnik.Style()
gpxrule = mapnik.Rule()
lns = mapnik.LineSymbolizer()
stroke = mapnik.Stroke()
stroke.color = mapnik.Color('#FF6600')
if highres:
stroke.width = 10
else:
stroke.width = 5
stroke.opacity = 0.9
stroke.line_join = mapnik.line_join.names['round']
stroke.line_cap = mapnik.line_cap.names['round']
lns.stroke = stroke
gpxrule.symbols.append(lns)
gpxstyle.rules.append(gpxrule)
m.append_style('gpxstyle', gpxstyle)
gpxlayer = mapnik.Layer('gpx')
gpxlayer.datasource = mapnik.Ogr(file=line, layer='OGRGeoJSON')
gpxlayer.styles.append('gpxstyle')
m.layers.append(gpxlayer)
bbox = boxes[orientation]
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
return Image.open(StringIO(im.tostring('png')))
# Create the rule and style obj
r = mapnik.Rule()
s = mapnik.Style()
# Set the land polygone
polyStyle = mapnik.PolygonSymbolizer(mapnik.Color("darkred"))
pointStyle = mapnik.PointSymbolizer(mapnik.PathExpression(file_symbol))
r.symbols.append(polyStyle)
r.symbols.append(pointStyle)
s.rules.append(r)
map.append_style("mapStyle", s)
# Adding point layer
layerPoint = mapnik.Layer("pointLayer")
layerPoint.datasource = mapnik.Shapefile(file=os.path.join("data", "map.shp"))
layerPoint.styles.append("mapStyle")
# Adding polygon
layerPoly = mapnik.Layer("polyLayer")
layerPoly.datasource = mapnik.Shapefile(
file=os.path.join("data", "ne_110m_land.shp"))
layerPoly.styles.append("mapStyle")
# Add layers to map
map.layers.append(layerPoly)
map.layers.append(layerPoint)
# Set boundaries for the Netherlands
# Instanciate a layer. The parameters depend on the type of data:
# shape:
# 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=path.join(
root, '../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()
diseases = ("cchf", "chik", "deng", "hat", "melio", "nwcl", "owcl", "scrub")
diseases = ("hat", "nwcl", "owcl")
variants = ("1A", "1B", "1C", "2C", "2D", "3B", "4A", "5A", "6A")
variants = ("3B", "4A", "5A", "6A")
for disease in diseases:
for variant in variants:
geotiff = "all/results/" + disease + "_" + variant + "/prediction_uncertainty_masked.tif"
png = "all/results/" + disease + "_" + variant + "/prediction_uncertainty_masked.png"
symbolizer = mapnik.RasterSymbolizer()
colorizer = mapnik.RasterColorizer(
default_mode=mapnik.COLORIZER_LINEAR,
default_color=mapnik.Color("transparent"))
symbolizer.colorizer = colorizer
colorizer.add_stop(-9999.0, mapnik.Color("#000000"))
colorizer.add_stop(0.0, mapnik.Color("#d4e7f4"))
colorizer.add_stop(1.0, mapnik.Color("#5f8098"))
colorizer.add_stop(9999.0, mapnik.Color("#eaeaea"))
style = mapnik.Style()
rule = mapnik.Rule()
rule.symbols.append(symbolizer)
style.rules.append(rule)
layer = mapnik.Layer("raster")
layer.datasource = mapnik.Gdal(file=geotiff, nodata=-9999, band=1)
layer.styles.append("raster")
world = mapnik.Map(1656, 667)
world.append_style("raster", style)
world.layers.append(layer)
world.zoom_all()
mapnik.render_to_file(world, png, 'png')
