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
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
def render(self, input_file, extent, lyr_style):
proj4lyr = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
county_file = '../datas/county.shp'
# river_file = '../datas/river.shp'
# capital_file ='Capital3.json'
filename = os.path.split(input_file)[1]
areaCode = os.path.splitext(filename)[0]
output_file = input_file.split('.')[0] + '.png'
print areaCode
# ----------create map---------------------
m = mapnik.Map(extent.xsize, extent.ysize)
mapnik.load_map(m, 'cg_config.xml')
# ----------create layer 1-----------------
layer = mapnik.Layer('dataraster', proj4lyr)
# ----------create layer 1 datasource------
layer.datasource = mapnik.Gdal(file=input_file, band=1, nodata=-999)
layer.styles.append(lyr_style)
# ----------append layer 1 to map----------
m.layers.append(layer)
# ----------create layer 2-----------------
layer2 = mapnik.Layer('county', proj4lyr)
# Create new styles and add the rules.
s_county = m.find_style('county')
r_county = s_county.rules[0]
r_county.filter = mapnik.Filter('[CITY]=' + areaCode)
m.append_style(areaCode, s_county)
# ----------create layer 2 datasource------
layer2.datasource = mapnik.Shapefile(file=county_file)
layer2.styles.append(areaCode)
# ----------append layer 2 to map----------
m.layers.append(layer2)
# ----------create layer 3-----------------
layer3 = mapnik.Layer('capital', proj4lyr)
# Create new styles and add the rules.
s_capital = m.find_style('capital')
r_capital = s_capital.rules[0]
r_capital.filter = mapnik.Filter('[CITY]=' + areaCode)
m.append_style('symbol', s_capital)
# ----------create layer 3 datasource------
layer3.datasource = mapnik.Shapefile(file=county_file)
layer3.styles.append('symbol')
# ----------append layer 3 to map----------
m.layers.append(layer3)
ll = mapnik.Coord(extent.xmax, extent.ymax)
tr = mapnik.Coord(extent.xmin, extent.ymin)
map_bbox = mapnik.Box2d(tr, ll) # mapnik.Envelope(tr, ll)
m.zoom_to_box(map_bbox)
print m.envelope(), m.scale()
mapnik.render_to_file(m, output_file, 'png')
return 'true'
def make_map(self):
m = mapnik.Map(self._view.width, self._view.height)
m.srs = '+proj=merc +ellps=WGS84 +datum=WGS84 +no_defs'
m.background = mapnik.Color(default_colors.water_color)
s = mapnik.Style() # style object to hold rules
for (name, color) in self._name_to_color.items():
rule = make_rule(color)
rule.filter = mapnik.Filter("[%s] = '%s'" %
(self._field, name.encode('utf-8')))
s.rules.append(rule) # now add the rule to the style
m.append_style('My Style', s)
ds = mapnik.GeoJSON(file=self._district_file)
layer = mapnik.Layer('world')
layer.datasource = ds
layer.srs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
layer.styles.append('My Style')
m.layers.append(layer)
view = self._view
zoom_to_box(m, view.west, view.south, view.east, view.north)
return m
def to_mapnik(self, mmap, dirs=None):
"""
"""
prev_cwd = getcwd()
if dirs:
chdir(dirs.output)
try:
mmap.srs = self.srs or mmap.srs
if self.background:
mmap.background = mapnik.Color(str(self.background))
ids = (i for i in xrange(1, 999999))
for layer in self.layers:
for style in layer.styles:
sty = mapnik.Style()
for rule in style.rules:
rul = mapnik.Rule('rule %d' % ids.next())
rul.filter = rule.filter and mapnik.Filter(rule.filter.text) or rul.filter
rul.min_scale = rule.minscale and rule.minscale.value or rul.min_scale
rul.max_scale = rule.maxscale and rule.maxscale.value or rul.max_scale
for symbolizer in rule.symbolizers:
if not hasattr(symbolizer, 'to_mapnik'):
continue
sym = symbolizer.to_mapnik()
rul.symbols.append(sym)
sty.rules.append(rul)
mmap.append_style(style.name, sty)
lay = mapnik.Layer(layer.name)
lay.srs = layer.srs or lay.srs
if layer.datasource:
lay.datasource = layer.datasource.to_mapnik()
lay.minzoom = layer.minzoom or lay.minzoom
lay.maxzoom = layer.maxzoom or lay.maxzoom
for style in layer.styles:
lay.styles.append(style.name)
mmap.layers.append(lay)
except:
# pass it along, but first chdir back to the previous directory
# in the finally clause below, to put things back the way they were.
raise
finally:
chdir(prev_cwd)
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')
def add_style_level(self, s, percent):
color = "#{}".format(self.c1000_rainbow.colourAt(percent))
width_multiplier = self.get_width_multiplier(self.zoom)
# unpaved
r = mapnik.Rule()
r.filter = mapnik.Filter(self.filter_condition(False, percent))
ls = mapnik.LineSymbolizer()
ls.stroke = mapnik.Color(color)
ls.stroke_width = 0.1 * width_multiplier
r.symbols.append(ls)
s.rules.append(r)
#paved
r = mapnik.Rule()
r.filter = mapnik.Filter(self.filter_condition(True, percent))
ls = mapnik.LineSymbolizer()
ls.stroke = mapnik.Color(color)
ls.stroke_width = 1 * width_multiplier
r.symbols.append(ls)
s.rules.append(r)
def create_roi_output_style(attr_name):
qgis_style_file = os.path.join(os.path.dirname(__file__),
"plot_data/roi_pred_classes_4.qml")
symbols = {}
with open(qgis_style_file, 'rb') as qsf:
doc = etree.parse(qsf)
for range in doc.xpath('//range'):
upper = range.attrib['upper']
lower = range.attrib['lower']
label = range.attrib['label']
symbol = range.attrib['symbol']
symbols[symbol] = {
"lower": float(lower),
"upper": float(upper),
"label": str(label),
}
for node in doc.xpath("//prop[@k='color']"):
layer = node.getparent()
sym = layer.getparent()
sym_name = sym.attrib['name']
str_color = node.attrib["v"]
c = str_color.split(",")
symbols[sym_name]["color"] = mapnik.Color(
"rgb(%d,%d,%d)" % (int(c[0]), int(c[1]), int(c[2])))
style = mapnik.Style()
for sname in symbols:
r = mapnik.Rule()
psym = mapnik.MarkersSymbolizer()
psym.fill = symbols[sname]["color"]
psym.width = mapnik.Expression('6')
psym.height = mapnik.Expression('6')
psym.stroke = mapnik.Stroke(mapnik.Color('white'), 0)
r.symbols.append(psym)
upper = symbols[sname]["upper"]
lower = symbols[sname]["lower"]
f = mapnik.Filter("[%s] >= %f and [%s] < %f" %
(attr_name, lower, attr_name, upper))
r.filter = f
style.opacity = 0.8
style.rules.append(r)
return style
def test_filter_init():
m = mapnik.Map(1, 1)
mapnik.load_map_from_string(m, map_)
filters = []
filters.append(mapnik.Filter("([region]>=0) and ([region]<=50)"))
filters.append(mapnik.Filter("(([region]>=0) and ([region]<=50))"))
filters.append(mapnik.Filter("((([region]>=0) and ([region]<=50)))"))
filters.append(mapnik.Filter('((([region]>=0) and ([region]<=50)))'))
filters.append(mapnik.Filter('''((([region]>=0) and ([region]<=50)))'''))
filters.append(
mapnik.Filter('''
((([region]>=0)
and
([region]<=50)))
'''))
filters.append(
mapnik.Filter('''
([region]>=0)
and
([region]<=50)
'''))
filters.append(
mapnik.Filter('''
([region]
>=
0)
and
([region]
<=
50)
'''))
s = m.find_style('s')
for r in s.rules:
filters.append(r.filter)
first = filters[0]
for f in filters:
eq_(str(first), str(f))
s = m.find_style('s2')
eq_(s.filter_mode, mapnik.filter_mode.FIRST)
def UnicodePolyStyle(self, field, feats, colors):
if len(feats) != len(colors):
print "Error: length of fields and the specified colors should be the same!"
polyS = mapnik.Style()
for i in range(0, len(feats)):
r = mapnik.Rule()
r.filter = mapnik.Filter("[" + field + "] = '" + feats[i] + "'")
s = mapnik.PolygonSymbolizer(mapnik.Color(colors[i]))
r.symbols.append(s)
polyS.rules.append(r)
r = mapnik.Rule()
s = mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.1)
r.symbols.append(s)
polyS.rules.append(r)
return polyS
def make_rules_for_input_combinations(self,
possible_values,
value_dict={}):
"""
Recursive function to loop all possible input
combinations. For each input combination, calculate rule name
and rule.
possible_values: dict of fieldname as key and a dict of {value: None}
value_dict: dict of all current values (starts empty)
Return a dictionary with all rulename as key and rule as value.
"""
if possible_values:
#not all possible values are put into value_dicts
fieldname, fieldvalues = possible_values.items()[0]
del possible_values[fieldname]
rules = {}
for fieldvalue in fieldvalues.keys():
new_rules = self.make_rules_for_input_combinations(
possible_values, {fieldname: fieldvalue})
rules.update(new_rules)
return rules
else:
#possible values are empty, all values are listed in value_dict
rule_name = self.get_rule_name(value_dict)
symbol_kwargs = self.get_output_properties(value_dict)
symbol_out = symbol_kwargs['symbol'][0] + '.png'
size_out_x, size_out_y = symbol_kwargs['size']
filename_abs = str(
self.sm.get_symbol_transformed(symbol_out, **symbol_kwargs))
mapnik_rule = mapnik.Rule()
ps = mapnik.PointSymbolizer()
ps.file = filename_abs
mapnik_rule.symbols.append(ps)
mapnik_rule.filter = mapnik.Filter(
str("[NAME] = '%s'" % (rule_name)))
return {rule_name: mapnik_rule}
def _add_rivers(m, colors):
s = mapnik.Style()
r = mapnik.Rule()
r.filter = mapnik.Filter(
"[name] = 'Volga' or [name] = 'Dnipro' or [name] = 'Don' or [name] = 'Kama'"
)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color(colors.water_color)
line_symbolizer.stroke_width = 0.4
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('RiverStyle', s)
ds = mapnik.Shapefile(
file=SHAPEDIR +
'ne_10m_rivers_lake_centerlines/ne_10m_rivers_lake_centerlines.shp')
layer = mapnik.Layer('rivers')
layer.datasource = ds
layer.srs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
layer.styles.append('RiverStyle')
m.layers.append(layer)
def to_mapnik(self, mmap):
"""
"""
mmap.srs = self.srs or mmap.srs
mmap.bgcolor = str(self.bgcolor) or mmap.bgcolor
ids = (i for i in xrange(1, 999999))
for layer in self.layers:
for style in layer.styles:
sty = mapnik.Style()
for rule in style.rules:
rul = mapnik.Rule('rule %d' % ids.next())
rul.filter = rule.filter and mapnik.Filter(
rule.filter.text) or rul.filter
rul.min_scale = rule.minscale and rule.minscale.value or rul.min_scale
rul.max_scale = rule.maxscale and rule.maxscale.value or rul.max_scale
for symbolizer in rule.symbolizers:
if not hasattr(symbolizer, 'to_mapnik'):
continue
sym = symbolizer.to_mapnik()
rul.symbols.append(sym)
sty.rules.append(rul)
mmap.append_style(style.name, sty)
lay = mapnik.Layer(layer.name)
lay.srs = layer.srs or lay.srs
lay.minzoom = layer.minzoom or lay.minzoom
lay.maxzoom = layer.maxzoom or lay.maxzoom
for style in layer.styles:
lay.styles.append(style.name)
mmap.layers.append(lay)
def __add_sewers(self, layers, styles):
"Add sewer layer and styles."
# Get all sewer pipes that constitute to this sewerage.
sewers = Sewer.objects.filter(sewerage__pk=self.id)
# Define a style.
style = mapnik.Style()
# QUALITY_UNKNOWN
rule = mapnik.Rule()
rule.filter = mapnik.Filter(
"[quality] = {}".format(Sewer.QUALITY_UNKNOWN)
)
rule.max_scale = 1700
symbol = mapnik.TextSymbolizer(
'code', 'DejaVu Sans Book', 10, mapnik.Color('blue')
)
symbol.allow_overlap = True
# symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT
rule.symbols.append(symbol)
style.rules.append(rule)
# QUALITY_RELIABLE
rule = mapnik.Rule()
rule.filter = mapnik.Filter(
"[quality] = {}".format(Sewer.QUALITY_RELIABLE)
)
rule.max_scale = 1700
symbol = mapnik.TextSymbolizer(
'code', 'DejaVu Sans Book', 10, mapnik.Color('green')
)
symbol.allow_overlap = True
# symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT
symbol.allow_overlap = True
symbol.opacity = 1.0
rule.symbols.append(symbol)
style.rules.append(rule)
# QUALITY_UNRELIABLE
rule = mapnik.Rule()
rule.filter = mapnik.Filter(
"[quality] = {}".format(Sewer.QUALITY_UNRELIABLE)
)
rule.max_scale = 1700
symbol = mapnik.TextSymbolizer(
'code', 'DejaVu Sans Book', 10, mapnik.Color('red')
)
symbol.allow_overlap = True
# symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT
# symbol.displacement(16, 16) # slightly above
rule.symbols.append(symbol)
style.rules.append(rule)
# Setup datasource.
params = default_database_params()
params['table'] = "({}) data".format(sewers.query)
datasource = mapnik.PostGIS(**params)
# Define layer.
layer = mapnik.Layer('sewerLayer')
layer.datasource = datasource
layer.maxzoom = 35000
layer.styles.append('sewerStyle')
layers.append(layer)
styles['sewerStyle'] = style
def __add_measurements(self, layers, styles):
"Docstring."
measurements = SewerMeasurement.objects.filter(
sewer__sewerage__pk=self.id
)
style = mapnik.Style()
for _, _, min_pct, max_pct, color in CLASSES:
r, g, b, a = html_to_mapnik(color)
icon = SYMBOL_MANAGER.get_symbol_transformed(
RIOOL_ICON, color=(r, g, b, a)
)
rule = mapnik.Rule()
rule.filter = mapnik.Filter(
str("[flooded_pct] >= %s and [flooded_pct] < %s"
% (min_pct, max_pct))
)
symbol = mapnik.PointSymbolizer(
os.path.join(GENERATED_ICONS, icon), "png", 16, 16
)
symbol.allow_overlap = True
rule.symbols.append(symbol)
style.rules.append(rule)
# Style else rule.
r, g, b, a = html_to_mapnik('00000')
icon = SYMBOL_MANAGER.get_symbol_transformed(
RIOOL_ICON, color=(r, g, b, a)
)
rule = mapnik.Rule()
rule.set_else(True)
symbol = mapnik.PointSymbolizer(
os.path.join(GENERATED_ICONS, icon), "png", 16, 16
)
symbol.allow_overlap = True
rule.symbols.append(symbol)
style.rules.append(rule)
# Setup datasource.
params = default_database_params()
params['table'] = "({}) data".format(measurements.query)
datasource = mapnik.PostGIS(**params)
params = default_database_params()
# Define layer.
layer = mapnik.Layer('measurementLayer')
layer.datasource = datasource
layer.maxzoom = 35000
layer.styles.append('measurementStyle')
layers.append(layer)
styles['measurementStyle'] = style
layer = mapnik.Layer("unused_roads")
layer.datasource = mapnik.PostGIS(host='localhost',
user='******',
password='',
dbname='gps_heatmap',
table='road_segments')
layer.styles.append("unused_road_style")
map.layers.append(layer)
# Set up our unused road layer style.
line_symbol = mapnik.LineSymbolizer(mapnik.Color("#c0c0c0"), 1.0)
rule = mapnik.Rule()
rule.filter = mapnik.Filter("[tally] = 0")
rule.symbols.append(line_symbol)
style = mapnik.Style()
style.rules.append(rule)
map.append_style("unused_road_style", style)
# Define our used road layer.
layer = mapnik.Layer("used_roads")
layer.datasource = mapnik.PostGIS(host='localhost',
user='******',
password='',
dbname='gps_heatmap',
table='road_segments')
layer.styles.append("used_road_style")
#!/usr/bin/env python
import mapnik
precinct_style = mapnik.Style()
roads_style = mapnik.Style()
for roads in range(1, 884):
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()
symbolizer.stroke = mapnik.Stroke(mapnik.Color('#FF7700'), 1)
rule.symbols.append(symbolizer)
roads_style.rules.append(rule)
layer = mapnik.Layer("Roads Layer")
layer.datasource = mapnik.Shapefile(file="data/Roads.shp")
layer.styles.append("Roads Style")
map1 = mapnik.Map(1024, 1024)
map1.background = mapnik.Color("#EEEEEE")
map1.append_style("Roads Style", roads_style)
map1.layers.append(layer)
map1.zoom_all()
def generateMap(tableName,
minX,
minY,
maxX,
maxY,
mapWidth,
mapHeight,
hiliteExpr=None,
points=None):
extent = "{},{},{},{}".format(minX, minY, maxX, maxY)
layer = mapnik.Layer("Layer")
layer.datasource = mapnik.PostGIS(dbname="distal",
table=tableName,
user="******",
password="******",
extent=extent,
geometry_field="outline",
srid=4326)
map = mapnik.Map(mapWidth, mapHeight, '+proj=longlat +datum=WGS84')
map.background = mapnik.Color("#8080a0")
style = mapnik.Style()
rule = mapnik.Rule()
if hiliteExpr != None:
rule.filter = mapnik.Filter(hiliteExpr)
rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#408000")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Stroke(mapnik.Color("#000000"), 0.1)))
style.rules.append(rule)
rule = mapnik.Rule()
rule.set_else(True)
rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#a0a0a0")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Stroke(mapnik.Color("#404040"), 0.1)))
style.rules.append(rule)
map.append_style("Map Style", style)
layer.styles.append("Map Style")
map.layers.append(layer)
if points != None:
memoryDatasource = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push("name")
next_id = 1
for long, lat, name in points:
wkt = "POINT (%0.8f %0.8f)" % (long, lat)
feature = mapnik.Feature(context, next_id)
feature['name'] = name
feature.add_geometries_from_wkt(wkt)
next_id = next_id + 1
memoryDatasource.add_feature(feature)
layer = mapnik.Layer("Points")
layer.datasource = memoryDatasource
style = mapnik.Style()
rule = mapnik.Rule()
pointImgFile = os.path.join(os.path.dirname(__file__), "point.png")
shield = mapnik.ShieldSymbolizer(mapnik.Expression('[name]'),
"DejaVu Sans Bold", 10,
mapnik.Color("#000000"),
mapnik.PathExpression(pointImgFile))
shield.displacement = (0, 7)
shield.unlock_image = True
rule.symbols.append(shield)
style.rules.append(rule)
map.append_style("Point Style", style)
layer.styles.append("Point Style")
map.layers.append(layer)
map.zoom_to_box(mapnik.Envelope(minX, minY, maxX, maxY))
scriptDir = os.path.dirname(__file__)
cacheDir = os.path.join(scriptDir, "..", "mapCache")
if not os.path.exists(cacheDir):
os.mkdir(cacheDir)
fd, filename = tempfile.mkstemp(".png", dir=cacheDir)
os.close(fd)
mapnik.render_to_file(map, filename, "png")
return "../mapCache/" + os.path.basename(filename)
timeStart = time.time()
m = mapnik.Map(256, 256)
m.background = mapnik.Color('white')
shpLayer = mapnik.Layer('SHP')
shpLayer.datasource = mapnik.Shapefile(
file=r"D:\LIJUNGANG\work\MapServer\mapnik_data\dltb_clip.shp")
lineLayer = mapnik.Layer('Line')
lineLayer.datasource = mapnik.Shapefile(
file=r"D:\LIJUNGANG\work\MapServer\mapnik_data\xzdm_clip.shp")
shpStyle = mapnik.Style()
shpStyle.filter_mode = mapnik.filter_mode.FIRST
#forestRule=mapnik.Rule()
farmlandRule011 = mapnik.Rule()
filter011 = mapnik.Filter("[DLBM]='011'")
farmlandRule011.filter = filter011
farmlandRule011.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("rgb(255,255,100)")))
shpStyle.rules.append(farmlandRule011)
farmlandRule012 = mapnik.Rule()
filter012 = mapnik.Filter("[DLBM]='012'")
farmlandRule012.filter = filter012
farmlandRule012.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("rgb(255,255,150)")))
shpStyle.rules.append(farmlandRule012)
farmlandRule013 = mapnik.Rule()
filter013 = mapnik.Filter("[DLBM]='013'")
farmlandRule013.filter = filter013
def main():
""" Our main program.
"""
# Open up each layer's data source, remember the projection, and calculate
# the overall boundary for all the displayed data that matches our bounds
# filter.
projections = []
minLong = None
maxLong = None
minLat = None
maxLat = None
try:
boundsFilter = BOUNDS_FILTER
except NameError:
boundsFilter = {}
for i in range(len(LAYERS)):
src = LAYERS[i]
print "Processing " + src['sourceFile'] + "..."
shapefile = osgeo.ogr.Open(src['sourceFile'])
layer = shapefile.GetLayer(0)
spatialRef = layer.GetSpatialRef()
if spatialRef != None:
projection = spatialRef.ExportToProj4()
else:
if len(projections) > 0:
projection = projections[0]
else:
spatialRef = osgeo.osr.SpatialReference()
spatialRef.SetWellKnownGeogCS('WGS84')
projection = spatialRef.ExportToProj4()
for i in range(layer.GetFeatureCount()):
feature = layer.GetFeature(i)
matches = True
for key, value in boundsFilter.items():
if feature.GetField(key) != value:
matches = False
break
if not matches:
continue
if src.get("printAttrs") == True:
print " " + repr(feature.items().items())
bounds = feature.GetGeometryRef().GetEnvelope()
if minLong == None:
minLong, maxLong, minLat, maxLat = bounds
else:
if bounds[0] < minLong: minLong = bounds[0]
if bounds[1] > maxLong: maxLong = bounds[1]
if bounds[2] < minLat: minLat = bounds[2]
if bounds[3] > maxLat: maxLat = bounds[3]
projections.append(projection)
# Adjust the calculated bounds by the bounds margin, if any.
try:
minLong = minLong - BOUNDS_MARGIN
maxLong = maxLong + BOUNDS_MARGIN
minLat = minLat - BOUNDS_MARGIN
maxLat = maxLat + BOUNDS_MARGIN
except NameError:
pass
# If we've been asked to do so, print out the calculated bounds.
try:
if PRINT_BOUNDS:
print "MIN_LAT = %0.4f" % minLat
print "MAX_LAT = %0.4f" % maxLat
print "MIN_LONG = %0.4f" % minLong
print "MAX_LONG = %0.4f" % maxLong
except NameError:
pass
# Calculate the size of the map image, based on the calculated boundaries.
if OVERRIDE_MIN_LAT != None: minLat = OVERRIDE_MIN_LAT
if OVERRIDE_MAX_LAT != None: maxLat = OVERRIDE_MAX_LAT
if OVERRIDE_MIN_LONG != None: minLong = OVERRIDE_MIN_LONG
if OVERRIDE_MAX_LONG != None: maxLong = OVERRIDE_MAX_LONG
mapBounds = mapnik.Envelope(minLong, minLat, maxLong, maxLat)
aspectRatio = mapBounds.width() / mapBounds.height()
mapWidth = MAX_WIDTH
mapHeight = int(mapWidth / aspectRatio)
if mapHeight > MAX_HEIGHT:
# Scale the map to fit.
scaleFactor = float(MAX_HEIGHT) / float(mapHeight)
mapWidth = int(mapWidth * scaleFactor)
mapHeight = int(mapHeight * scaleFactor)
# Create our map.
m = mapnik.Map(mapWidth, mapHeight, projections[0])
m.background = mapnik.Color(BACKGROUND_COLOR)
# Setup the stylesheets to show the contents of each shapefile.
for i in range(len(LAYERS)):
src = LAYERS[i]
s = mapnik.Style()
r = mapnik.Rule()
if src.get("filter") != None:
r.filter = mapnik.Filter(src['filter'])
if src['fillColor'] != None:
ps = mapnik.PolygonSymbolizer(mapnik.Color(src['fillColor']))
r.symbols.append(ps)
if src['lineColor'] != None:
stroke = mapnik.Stroke(mapnik.Color(src['lineColor']),
src['lineWidth'])
if src.get("lineJoin") == "miter":
stroke.line_join = mapnik.line_join.MITER_JOIN
elif src.get("lineJoin") == "round":
stroke.line_join = mapnik.line_join.ROUND_JOIN
elif src.get("linJoin") == "bevel":
stroke.line_join = mapnik.line_join.BEVEL_JOIN
if src.get("lineCap") == "round":
stroke.line_cap = mapnik.line_cap.ROUND_CAP
elif src.get("lineCap") == "square":
stroke.line_cap = mapnik.line_cap.SQUARE_CAP
elif src.get("lineCap") == "butt":
stroke.line_cap = mapnik.line_cap.BUTT_CAP
if src.get("lineDash") != None:
stroke.add_dash(src['lineDash'], src['lineDash'] * 2)
ls = mapnik.LineSymbolizer(stroke)
r.symbols.append(ls)
if src['labelField'] != None:
ts = mapnik.TextSymbolizer(
mapnik.Expression("[" + src['labelField'] + "]"),
"DejaVu Sans Bold", src['labelSize'],
mapnik.Color(src['labelColor']))
if src.get("labelHalo") != None:
ts.halo_radius = src['labelHalo']
if src.get("labelPlacement") == "line":
ts.label_placement = mapnik.label_placement.LINE_PLACEMENT
if src.get("labelAllowOverlap") != None:
ts.allow_overlap = src['labelAllowOverlap']
else:
ts.allow_overlap = True
r.symbols.append(ts)
s.rules.append(r)
m.append_style("style-" + str(i + 1), s)
# Setup our various map layers.
for i in range(len(LAYERS)):
src = LAYERS[i]
l = mapnik.Layer("layer-" + str(i + 1), projections[i])
if src['sourceFile'].endswith(".shp"):
l.datasource = mapnik.Shapefile(file=src['sourceFile'])
else:
l.datasource = mapnik.Ogr(file=src['sourceFile'],
layer=src.get("layer"))
l.styles.append("style-" + str(i + 1))
m.layers.append(l)
# Finally, render the map.
m.zoom_to_box(mapBounds)
mapnik.render_to_file(m, "map.png", "png")
os.system("open map.png")
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')
def tileMapConfig(map_id):
map_selected = BasquiMap.objects.get(pk=map_id)
layersMapOptions = LayerMapOptions.objects.filter(
basqui_map=map_selected).order_by('-position')
layers_used = Shapefile.objects.filter(
Q(layermapoptions__basqui_map=map_selected),
Q(layermapoptions__style_visible=True)
| Q(layermapoptions__label_visible=True))
mapXML = mapnik.Map(
TILE_WIDTH, TILE_HEIGHT,
"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over"
)
mapXML.buffer_size = 128
if len(layers_used) > 0:
query = """(SELECT shapefile_id, coalesce(geom_multipoint, geom_multilinestring, geom_multipolygon) as g
%s
FROM layers_feature WHERE shapefile_id IN (%s)
AND (geom_multipoint && !bbox! OR geom_multilinestring && !bbox! OR geom_multipolygon && !bbox! )
) as geom""" % (''.join([
",attribute_value->'" + label.field.name + "' as " +
str(label.field.name).lower() + "_" + str(label.pk)
for x in layersMapOptions.filter(label_visible=True)
for label in x.layerlabel_set.all()
]).replace(',None', ''), ','.join([str(x.pk) for x in layers_used]))
#','.join(["attribute_value->'" + x.label.field.name +"'" if x.label is not None else 'None' for x in layersMapOptions ]).replace(',None',''),
datasource = mapnik.PostGIS(
host=dbSettings['HOST'],
user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
port=dbSettings['PORT'],
table=query,
geometry_field='g',
#extent_from_subquery=True,
estimate_extent=False,
srid=3857,
extent='-20037508.34, -20037508.34, 20037508.34, 20037508.34',
simplify_geometries=True,
geometry_table='layers_feature')
featureLayer = mapnik.Layer("tiled_layer")
featureLayer.srs = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over"
featureLayer.datasource = datasource
featureLayer.cache_features = True
#defining the feature layer styles
for layerMapOptions in layersMapOptions.filter(style_visible=True):
layerStyles = layerMapOptions.layerstyle_set.all().order_by(
'-position')
layer = layerMapOptions.layer
featureLayer.styles.append(
str(layer.name) + '_Styles_' + str(layerMapOptions.pk))
layer_style = mapnik.Style()
for layerStyle in layerStyles:
style_rule = mapnik.Rule()
if layerStyle.filter:
style_rule.filter = mapnik.Filter(
"[shapefile_id] = %s and (%s)" %
(layer.pk, str(layerStyle.filter)))
else:
style_rule.filter = mapnik.Filter("[shapefile_id] = %s" %
layer.pk)
if layerStyle.minScale:
style_rule.min_scale = layerStyle.minScale
if layerStyle.maxScale:
style_rule.max_scale = layerStyle.maxScale
if layer.geom_type in ["Point", "MultiPoint"]:
m = mapnik.MarkersSymbolizer()
m.filename = os.path.abspath("../media/%s" %
layerStyle.marker.svg)
m.fill = mapnik.Color(str(layerStyle.fill))
m.fill_opacity = layerStyle.fill_opacity
s = mapnik.Stroke()
s.color = mapnik.Color(str(layerStyle.stroke_color))
s.width = layerStyle.stroke_width
s.opacity = layerStyle.stroke_opacity
m.stroke = s
if layerStyle.transform:
m.transform = str(layerStyle.transform)
m.allow_overlap = layerStyle.allow_overlap
m.spacing = layerStyle.spacing
m.max_error = layerStyle.max_error
#m.placement = mapnik.marker_placement(layerStyle.placement)
#m.ignore_placement = layerStyle.ignore_placement
style_rule.symbols.append(m)
elif layer.geom_type in ["LineString", "MultiLineString"]:
l = mapnik.LineSymbolizer()
l.stroke.color = mapnik.Color(str(layerStyle.stroke_color))
l.stroke.width = layerStyle.stroke_width
l.stroke.opacity = layerStyle.stroke_opacity
l.stroke.line_join = mapnik.line_join(
layerStyle.stroke_linejoin)
l.stroke.line_cap = mapnik.line_cap(
layerStyle.stroke_linecap)
if layerStyle.dash_array:
dash_array = [
tuple(float(i) for i in el.strip('()').split(','))
for el in layerStyle.dash_array.split('),(')
]
for d in dash_array:
l.stroke.add_dash(d[0], d[1])
l.stroke.gamma = layerStyle.gamma
l.stroke.gamma_method = mapnik.gamma_method(
layerStyle.gamma_method)
l.smooth = layerStyle.smooth
l.simplify_tolerance = layerStyle.simplify_tolerance
l.offset = layerStyle.stroke_offset
l.clip = layerStyle.clip
l.rasterizer = mapnik.line_rasterizer(
layerStyle.stroke_rasterizer)
style_rule.symbols.append(l)
elif layer.geom_type in ["Polygon", "MultiPolygon"]:
p = mapnik.PolygonSymbolizer()
p.fill = mapnik.Color(str(layerStyle.fill))
p.fill_opacity = layerStyle.fill_opacity
p.clip = layerStyle.clip
p.gamma = layerStyle.gamma
p.gamme_method = mapnik.gamma_method(
layerStyle.gamma_method)
p.smooth = layerStyle.smooth
p.simplify_tolerance = layerStyle.simplify_tolerance
l = mapnik.LineSymbolizer()
l.stroke.color = mapnik.Color(str(layerStyle.stroke_color))
l.stroke.opacity = layerStyle.stroke_opacity
l.stroke.width = layerStyle.stroke_width
if layerStyle.dash_array:
dash_array = [
tuple(float(i) for i in el.strip('()').split(','))
for el in layerStyle.dash_array.split('),(')
]
for d in dash_array:
l.stroke.add_dash(d[0], d[1])
l.offset = layerStyle.stroke_offset
l.clip = layerStyle.clip
l.stroke.gamma = layerStyle.gamma
l.smooth = layerStyle.smooth
l.simplify_tolerance = layerStyle.simplify_tolerance
style_rule.symbols.append(p)
style_rule.symbols.append(l)
layer_style.rules.append(style_rule)
mapXML.append_style(
str(layer.name) + '_Styles_' + str(layerMapOptions.pk),
layer_style)
#defining label styles
for layerMapOptions in layersMapOptions.filter(label_visible=True):
layerLabels = layerMapOptions.layerlabel_set.all().order_by(
'-position')
layer = layerMapOptions.layer
featureLayer.styles.append(
str(layer.name) + '_Label_' + str(layerMapOptions.pk))
label_style = mapnik.Style()
for layerLabel in layerLabels:
label_rule = mapnik.Rule()
if layerLabel.filter:
label_rule.filter = mapnik.Filter(
"[shapefile_id] = %s and (%s)" %
(layer.pk, str(layerLabel.filter)))
else:
label_rule.filter = mapnik.Filter("[shapefile_id] = %s" %
layer.pk)
if layerLabel.minScale:
label_rule.min_scale = layerLabel.minScale
if layerLabel.maxScale:
label_rule.max_scale = layerLabel.maxScale
label_column = '[%s_%s]' % (str(
layerLabel.field).lower(), str(layerLabel.pk))
t = mapnik.TextSymbolizer(mapnik.Expression(label_column),
str(layerLabel.face_name),
layerLabel.size,
mapnik.Color(str(layerLabel.fill)))
t.halo_fill = mapnik.Color(str(layerLabel.halo_fill))
t.halo_radius = layerLabel.halo_radius
t.halo_rasterizer = mapnik.halo_rasterizer(
layerLabel.halo_rasterizer)
t.opacity = layerLabel.opacity
t.character_spacing = layerLabel.character_spacing
t.line_spacing = layerLabel.line_spacing
t.text_ratio = layerLabel.text_ratio
t.text_transform = mapnik.text_transform(
layerLabel.text_transform)
t.clip = layerLabel.clip
t.label_placement = mapnik.label_placement(
layerLabel.label_placement)
t.vertical_alignment = mapnik.vertical_alignment(
layerLabel.vertical_alignment)
t.horizontal_alignment = mapnik.horizontal_alignment(
layerLabel.horizontal_alignment)
t.justify_alignment = mapnik.justify_alignment(
layerLabel.justify_alignment)
t.displacement = (layerLabel.dx, layerLabel.dy)
t.orientation = mapnik.Expression(str(layerLabel.orientation))
t.rotate_displacement = layerLabel.rotate_displacement
t.label_position_tolerance = layerLabel.label_position_tolerance
t.avoid_edges = layerLabel.avoid_edges
t.minimum_padding = layerLabel.minimum_padding
t.allow_overlap = layerLabel.allow_overlap
t.minimum_distance = layerLabel.minimum_distance
t.repeat_distance = mapnik.Expression(
str(layerLabel.repeat_distance))
t.minimum_path_length = layerLabel.minimum_path_length
t.maximum_angle_char_delta = layerLabel.maximum_angle_char_delta
t.wrap_width = layerLabel.wrap_width
if layerLabel.wrap_character:
t.wrap_character = ord(layerLabel.wrap_character)
t.wrap_before = layerLabel.wrap_before
label_rule.symbols.append(t)
label_style.rules.append(label_rule)
mapXML.append_style(
str(layer.name) + '_Label_' + str(layerMapOptions.pk),
label_style)
mapXML.layers.append(featureLayer)
#saving the map mapnik xml
mapnik_xml_path = "../tilestache/%s/maps/viewer/%s_%s.xml" % (str(
map_selected.created_by.username), str(
map_selected.name), str(map_selected.pk))
mapnik.save_map(mapXML, mapnik_xml_path)
#!/usr/bin/env python
import mapnik
precinct_style = mapnik.Style()
roads_style = mapnik.Style()
for precinct in range(1, 53):
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)
def draw_district_outline(statefp, state, district, shpfeature, map_size, contextmap) :
# Create an image with district outlines and shading over the parts of the map
# in other districts or other states. Also compute our desired bounding box.
# Get bounding box of this map, which will be a little larger than the boudning box of the district.
long_min, long_max, lat_min, lat_max = shpfeature.GetGeometryRef().GetEnvelope()
margin = 0.06
if contextmap :
margin = 1.5
d_long = long_max-long_min
d_lat = lat_max-lat_min
long_min -= d_long*margin
long_max += d_long*margin
lat_min -= d_lat*margin
lat_max += d_lat*margin
# Choose an aspect ratio for the final image that is a good match for
# the shape of the district. We have two choices. We could use nice-looking
# aspect ratios or we could use aspect ratios that match common sizes of
# paper so that the map can be printed nicely.
good_aspect_ratios = [
(3.0, 3.0/1.0), # 8.5x17 tabloid landscape
(1.5, 16.0/9.0), # HD widescreen
(1.25, 11.0/8.5), # 8.5x11 letter landscape
(1/1.25, 1.0/1.0), # square
(1/1.5, 8.5/11.0), # 8.5x11 letter portrait
(0, 8.5/17.0), # 8.5x17 tabloid portrait
]
for threshold, ratio in good_aspect_ratios:
if d_long/d_lat > threshold:
if ratio > 1.0:
map_width = int(ratio * map_size)
map_height = map_size
else:
map_width = map_size
map_height = int(map_size / ratio)
break
# Create a map.
m = mapnik.Map(map_width, map_height, output_projection)
# Center to the projected coordinates.
bounds = (mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_min, lat_min)) ),
mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_max, lat_max)) ))
m.zoom_to_box(mapnik.Envelope(bounds[0].x, bounds[0].y, bounds[1].x, bounds[1].y))
if not contextmap :
# Add a layer for counties and ZCTAs.
# TODO: These should really be generated with the map tile layer
# so that the labels don't hit each other.
for layer, featurename, labelfontsize, labelcolor, border in (
("county", "NAME", map_size/40, mapnik.Color('rgb(70%,20%,20%)'), True),
("zcta510", "ZCTA5CE10", map_size/60, mapnik.Color('rgb(40%,40%,80%)'), False),
):
s = mapnik.Style()
r = mapnik.Rule()
if border:
p = mapnik.LineSymbolizer(labelcolor, map_size/300)
p.stroke.opacity = .3
p.stroke.add_dash(.1, .1)
r.symbols.append(p)
r.symbols.append(mapnik.TextSymbolizer(mapnik.Expression('[%s]' % featurename), mapnik_label_font, labelfontsize, labelcolor))
s.rules.append(r)
m.append_style('%s Style' % layer, s)
lyr = mapnik.Layer('world', census_shapefile_projection)
lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_%s.shp" % layer)
lyr.styles.append('%s Style' % layer)
m.layers.append(lyr)
# Draw shading and numbering for the other districts.
district_outline_color = mapnik.Color('rgb(100%,75%,25%)')
s = mapnik.Style()
r = mapnik.Rule()
p = mapnik.PolygonSymbolizer(mapnik.Color('rgb(70%,70%,70%)'))
p.fill_opacity = .55
r.symbols.append(p)
r.filter = mapnik.Filter("([CD113FP] <> '" + district + "' || [STATEFP] <> '" + statefp + "') && [CD113FP] != 'ZZ'")
t = mapnik.TextSymbolizer(mapnik.Expression('[CD113FP]'), mapnik_label_font, map_size/15, district_outline_color)
t.halo_radius = map_size/120
r.symbols.append(t)
s.rules.append(r)
# Draw the outlines of districts. Use a hard thin outline to be exact plus
# a faded wider outline for strength.
r = mapnik.Rule()
p = mapnik.LineSymbolizer(district_outline_color, 2)
r.symbols.append(p)
p = mapnik.LineSymbolizer(district_outline_color, map_size/140)
p.stroke.opacity = .35
r.symbols.append(p)
s.rules.append(r)
m.append_style('Other Districts Style',s)
lyr = mapnik.Layer('world', census_shapefile_projection)
lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_cd113.shp")
lyr.styles.append('Other Districts Style')
m.layers.append(lyr)
im = mapnik.Image(map_width, map_height)
mapnik.render(m, im)
env = m.envelope()
env = ( mapnik.Projection(output_projection).inverse(mapnik.Coord(env[0], env[1])), mapnik.Projection(output_projection).inverse(mapnik.Coord(env[2], env[3])) )
return im, env
#!/usr/bin/env python
import os
import mapnik
# create basemap
m = mapnik.Map(800, 600)
mapnik.load_map(m, 'population.xml')
# grab the countries layer
countries = m.layers[0]
ds = countries.datasource
countries.styles.append('selected')
featureset = ds.all_features()
criteria = mapnik.Filter("[POP2005] > 100000000")
# get features that pass criteria
queryset = [f for f in featureset if criteria.passes(f)]
for feature in queryset:
m.zoom_to_box(feature.envelope())
m.zoom(1.05)
name = str(feature.attributes['NAME'])
print 'Matched %s...' % name
feature_filter = mapnik.Filter("[NAME] = '%s'" % name)
# selected/highlighted style
s, r = mapnik.Style(), mapnik.Rule()
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('darkorange'), 3))
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('yellow'), 2))
t = mapnik.TextSymbolizer('NAME', 'DejaVu Sans Book', 30,
import mapnik
MIN_LAT = -35
MAX_LAT = +35
MIN_LONG = -12
MAX_LONG = +50
MAP_WIDTH = 700
MAP_HEIGHT = 800
# Define our polygon styles:
polygonStyle = mapnik.Style()
rule = mapnik.Rule()
rule.filter = mapnik.Filter("[NAME] = 'Angola'")
symbol = mapnik.PolygonSymbolizer(mapnik.Color("#604040"))
rule.symbols.append(symbol)
polygonStyle.rules.append(rule)
rule = mapnik.Rule()
rule.filter = mapnik.Filter("[NAME] != 'Angola'")
symbol = mapnik.PolygonSymbolizer(mapnik.Color("#406040"))
rule.symbols.append(symbol)
polygonStyle.rules.append(rule)
rule = mapnik.Rule()
symbol = mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.1)
rule.symbols.append(symbol)
blue = mapnik.PointSymbolizer('b.png', 'png', 50, 50)
blue.allow_overlap = True
# create point symbolizer for yellow icons
yellow = mapnik.PointSymbolizer('y.png', 'png', 50, 50)
yellow.allow_overlap = True
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(text)
s.rules.append(r)
s2 = mapnik.Style()
r2 = mapnik.Rule()
r2.symbols.append(blue)
r2.filter = mapnik.Filter("[Name] = 'blue!'")
s2.rules.append(r2)
r3 = mapnik.Rule()
r3.symbols.append(yellow)
r3.filter = mapnik.Filter("[Name] = 'yellow!'")
s2.rules.append(r3)
icons = mapnik.Layer('Memory Datasource')
icons.datasource = pds
icons.styles.append('Point Style')
m.layers.append(icons)
labels = mapnik.Layer('Memory Datasource')
labels.datasource = pds
labels.styles.append('Label Style')
