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 singlePointStyle(self, name=None, scale=0.2):
pointS = mapnik.Style()
r = mapnik.Rule()
if name is not None:
#s=mapnik.PointSymbolizer(name,"png",size,size)
s = mapnik.PointSymbolizer(name)
else:
s = mapnik.PointSymbolizer()
s.allow_overlap = True
s.transform = "scale(" + str(scale) + "," + str(scale) + ")"
r.symbols.append(s)
pointS.rules.append(r)
return pointS
def render(self, shp_address=[WORK_DIR+'all_point.shp',WORK_DIR+'path_point.shp',\
WORK_DIR+'way.shp',WORK_DIR+'src_point.shp'], \
save_add = WORK_DIR+'output.png', graph_size = [1200,1200], bg = '#000000'):
graph = mapnik.Map(graph_size[0], graph_size[1])
style = mapnik.Style()
rule = mapnik.Rule()
#polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('white'))
#rule.symbols.append(polygon_symbolizer)
point_symbolizer = mapnik.PointSymbolizer(
mapnik.PathExpression(WORK_DIR + "fig\red_small.png"))
rule.symbols.append(point_symbolizer)
apoint_symbolizer = mapnik.PointSymbolizer(
mapnik.PathExpression(WORK_DIR +
"fig\blue_small.png")) #along the path
rule.symbols.append(apoint_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('#00FA9A'),
3) #the path
rule.symbols.append(line_symbolizer)
ypoint_symbolizer = mapnik.PointSymbolizer(
mapnik.PathExpression(WORK_DIR +
"fig\yellow_small.png")) # the src point
rule.symbols.append(ypoint_symbolizer)
style.rules.append(rule)
graph.backgroud = mapnik.Color(bg)
graph.append_style('default', style)
#layer = ['polygon','line','point']
#address = [poly_add, line_add, node_add]
layer = ['point', 'point', 'line', 'point']
address = [item for item in shp_address]
for l1 in xrange(len(address)):
ds = mapnik.Shapefile(file=address[l1])
lay = mapnik.Layer(layer[l1])
lay.datasource = ds
lay.styles.append('default')
graph.layers.append(lay)
graph.zoom_all()
mapnik.render_to_file(graph, save_add, 'png')
def polygon_map():
m = mapnik.Map(600, 300) # create a map with a given width and height in pixels
# note: m.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
# the 'map.srs' is the target projection of the map and can be whatever you wish
m.background = mapnik.Color('steelblue') # set background colour to 'steelblue'.
s = mapnik.Style() # style object to hold rules
r = mapnik.Rule() # rule object to hold symbolizers
# to fill a polygon we create a PolygonSymbolizer
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#f2eff9')
r.symbols.append(polygon_symbolizer) # add the symbolizer to the rule object
# to add outlines to a polygon we create a LineSymbolizer
sym = mapnik.PointSymbolizer()
# args are file, type, height, width
sym.allow_overlap = True
sym.opacity = .5
r.symbols.append(sym)
'''line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)')
line_symbolizer.stroke_width = 0.1
r.symbols.append(line_symbolizer)'''# add the symbolizer to the rule object
s.rules.append(r) # now add the rule to the style and we're done
m.append_style('My Style', s) # Styles are given names only as they are applied to the map
ds = mapnik.Shapefile(file='I:\Data\shashankdata\LSMDATASET\INVENTORY\INVENTORY.shp')
layer = mapnik.Layer('Petrolling Party') # new layer called 'world' (we could name it anything)
# note: layer.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
# Write the data to a png image called world.png in the current directory
mapnik.render_to_file(m, 'C:\Users\Hp\Desktop\pol\sha.png', 'png')
# Exit the Python interpreter
exit() # or ctrl-d
def test_mutability_of_styles_by_find_style():
"""
Should be able to mutate style by a reference
returned from find_style()
"""
p = mapnik.PointSymbolizer()
p.allow_overlap = True
p.opacity = 0.5
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(256, 256)
m.append_style('s', s)
s2 = m.find_style('s')
eq_(len(s2.rules), 1)
s3 = m.find_style('s')
s3.rules.append(mapnik.Rule())
# Both referefences should point to the same object
eq_(len(s3.rules), 2)
eq_(len(s2.rules), 2)
def test_mutability_of_styles_from_iterator():
"""
Should be able to mutate style by a reference
returned from the iterator
"""
p = mapnik.PointSymbolizer()
p.allow_overlap = True
p.opacity = 0.5
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(256, 256)
m.append_style('s', s)
for style_name, style in m.styles:
eq_(style_name, 's')
eq_(len(style.rules), 1)
style.rules.append(mapnik.Rule())
eq_(len(style.rules), 2)
for style_name, style in m.styles:
eq_(style_name, 's')
eq_(len(style.rules), 2)
def test_render_points():
if not mapnik.has_cairo():
return
# create and populate point datasource (WGS84 lat-lon coordinates)
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push('Name')
f = mapnik.Feature(context, 1)
f['Name'] = 'Westernmost Point'
f.geometry = mapnik.Geometry.from_wkt('POINT (142.48 -38.38)')
ds.add_feature(f)
f = mapnik.Feature(context, 2)
f['Name'] = 'Southernmost Point'
f.geometry = mapnik.Geometry.from_wkt('POINT (143.10 -38.60)')
ds.add_feature(f)
# create layer/rule/style
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.PointSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places',
'+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
lyr.datasource = ds
lyr.styles.append('places_labels')
# latlon bounding box corners
ul_lonlat = mapnik.Coord(142.30, -38.20)
lr_lonlat = mapnik.Coord(143.40, -38.80)
# render for different projections
projs = {
'google':
'+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 +wktext +no_defs +over',
'latlon': '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs',
'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
'utm': '+proj=utm +zone=54 +datum=WGS84'
}
for projdescr in projs:
m = mapnik.Map(1000, 500, projs[projdescr])
m.append_style('places_labels', s)
m.layers.append(lyr)
dest_proj = mapnik.Projection(projs[projdescr])
src_proj = mapnik.Projection('+init=epsg:4326')
tr = mapnik.ProjTransform(src_proj, dest_proj)
m.zoom_to_box(tr.forward(mapnik.Box2d(ul_lonlat, lr_lonlat)))
# Render to SVG so that it can be checked how many points are there
# with string comparison
svg_file = os.path.join(tempfile.gettempdir(),
'mapnik-render-points-%s.svg' % projdescr)
mapnik.render_to_file(m, svg_file)
num_points_present = len(list(ds.all_features()))
with open(svg_file, 'r') as f:
svg = f.read()
num_points_rendered = svg.count('<image ')
eq_(
num_points_present, num_points_rendered,
"Not all points were rendered (%d instead of %d) at projection %s"
% (num_points_rendered, num_points_present, projdescr))
def render_png(self, show=True):
import mapnik
#TODO scale dimensions to aspect ratio of data
m = mapnik.Map(800, 400)
m.background = mapnik.Color('white')
s = mapnik.Style()
r = mapnik.Rule()
if "point" in self.collection().schema['geometry'].lower():
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
else:
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color('#f2eff9'))
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(
mapnik.Color('rgb(50%,50%,50%)'), 0.8)
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Shapefile(file=self.path)
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
outfile = '/tmp/world.png'
mapnik.render_to_file(m, outfile, 'png')
if show:
im = Image.open(outfile)
im.show()
return outfile
def render_tile(layer, z, x, y):
"""
Render the tile using mapnik.
"""
m = mapnik.Map(TILE_WIDTH, TILE_WIDTH)
s = mapnik.Style()
r = mapnik.Rule()
point_sym = mapnik.PointSymbolizer()
point_sym.allow_overlap = True
point_sym.opacity = 10.0
point_sym.file = ()
r.symbols.append(point_sym)
point = mapnik.PointSymbolizer()
r.symbols.append(point)
s.rules.append(r)
m.append_style('Ruben', s)
# Initialize layer from PostGIS table
ds = mapnik.PostGIS(**POSTGIS_TABLE)
layer = mapnik.Layer(LAYER_NAME)
layer.datasource = ds
layer.styles.append('Ruben')
m.layers.append(layer)
m.zoom_all()
# ds = mapnik.Shapefile(file='C:\Users\ICS\Documents\kuliah\gis\gis mapnik\pantai indonesia\IND_PNT_polyline.shp')
# layer = mapnik.Layer(LAYER_NAME)
# layer.datasource = ds
# layer.styles.append('My Style')
# m.layers.append(layer)
# m.zoom_all()
renderer = TiledMapRenderer(m)
im = renderer.render_tile(z, x, y)
# im = mapnik.Image(TILE_WIDTH, TILE_WIDTH)
# mapnik.render(m, im, 13, 0, 0)
# im.save('tmp/bla.png')
# mapnik.render_to_file(m,'aaa.png', 'png')
return im.tostring('png'), 200, {'Content-type': 'image/png'}
def _render(themap, filename, format):
m = themap.get_base_map().make_map()
ctx = mapnik.Context()
symbol_layers = {}
for symbol in themap.get_symbols():
svgfile = '/tmp/%s.svg' % symbol.get_id()
_generate_svg(svgfile, symbol)
ps = mapnik.PointSymbolizer()
ps.file = svgfile
ps.allow_overlap = True
ps.ignore_placement = True
r = mapnik.Rule()
r.symbols.append(ps)
s = mapnik.Style()
s.rules.append(r)
m.append_style('symbol_' + symbol.get_id(), s)
ix = 0
for marker in themap.get_markers():
f = mapnik.Feature.from_geojson(
json.dumps({
"type": "Feature",
"geometry": {
"type":
"Point",
"coordinates": [
float(marker.get_longitude()),
float(marker.get_latitude())
]
}
}), ctx)
ds = mapnik.MemoryDatasource()
symbol_layers[symbol.get_id()] = ds
l = mapnik.Layer('layer_%s' % ix)
ix += 1
l.clear_label_cache = True
l.datasource = ds
l.styles.append('symbol_' + marker.get_symbol().get_id())
m.layers.append(l)
ds.add_feature(f)
mapnik.render_to_file(m, filename, format)
box = None
if themap.has_legend() and themap.has_symbols() and format == 'png':
used_symbols = [
s for s in themap.get_symbols() if themap.is_symbol_used(s)
]
box = _add_legend(filename, used_symbols)
return box
def tms(z, x, y, service):
# (4370311.220000, 4911352.860000) - (4403732.650000, 4958349.910000)
# Extent: (4370177.610000, 4908530.650000) - (4411390.670000, 4958581.500000)
bbox = dict(minx=4370177, miny=4908530, maxx=4411390, maxy=4958581)
step = max(bbox['maxx'] - bbox['minx'], bbox['maxy'] - bbox['miny']) / 2**z
extents = dict()
extents['tms'] = (bbox['minx'] + x * step, bbox['miny'] + y * step,
bbox['minx'] + (x + 1) * step,
bbox['miny'] + (y + 1) * step)
extents['xyz'] = (bbox['minx'] + x * step, bbox['maxy'] - (y + 1) * step,
bbox['minx'] + (x + 1) * step, bbox['maxy'] - y * step)
tile = dict(width=256, height=256)
map = mapnik.Map(tile['width'], tile['height'])
map.background = mapnik.Color('steelblue')
mapnik.load_map(map, 'tile_server/style/styles.xml')
layer = mapnik.Layer('point')
ds = mapnik.PostGIS(host='127.0.0.1',
dbname='isogd_sevastopol',
user='******',
password='******',
table='tableapi.table_test_2_points_2')
layer.datasource = ds
pdb.set_trace()
style = mapnik.Style()
rule = mapnik.Rule()
point_symbolizer = mapnik.PointSymbolizer()
point_symbolizer.file = "/style/point_style.png"
# pdb.set_trace()
rule.symbols.append(point_symbolizer)
style.rules.append(rule)
map.append_style('My Style', style)
map.zoom_all()
mapnik.render_to_file(map, 'altay.png', 'png')
box = mapnik.Box2d(*extents.get(service))
# map.zoom_all()
map.zoom_to_box(box)
mapnik.render_to_file(map, 'world.png', 'png')
im = mapnik.Image(map.width, map.height)
mapnik.render(map, im)
output = im.tostring('png')
# box = mapnik.Box2d(*extents.get(service))
# map.zoom_to_box(box)
# mapnik.render_to_file(map, 'world.png', 'png')
# im = mapnik.Image(map.width, map.height)
# mapnik.render(map, im)
# output = im.tostring('png')
# # Передаём ответ клиенту
return output
def mapnik_style(self):
try:
import mapnik
except:
import mapnik2 as mapnik
point_style = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(mapnik.PointSymbolizer())
point_style.rules.append(r)
return point_style
def test_pointsymbolizer_init():
p = mapnik.PointSymbolizer()
eq_(p.allow_overlap, False)
eq_(p.opacity, 1)
eq_(p.filename, '')
eq_(p.ignore_placement, False)
eq_(p.placement, mapnik.point_placement.CENTROID)
p = mapnik.PointSymbolizer(
mapnik.PathExpression("../data/images/dummy.png"))
p.allow_overlap = True
p.opacity = 0.5
p.ignore_placement = True
p.placement = mapnik.point_placement.INTERIOR
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.filename, '../data/images/dummy.png')
eq_(p.ignore_placement, True)
eq_(p.placement, mapnik.point_placement.INTERIOR)
def test_introspect_symbolizers():
# create a symbolizer
p = mapnik.PointSymbolizer()
p.file = "../data/images/dummy.png"
p.allow_overlap = True
p.opacity = 0.5
# make sure the defaults
# are what we think they are
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.filename, '../data/images/dummy.png')
# contruct objects to hold it
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(0, 0)
m.append_style('s', s)
# try to figure out what is
# in the map and make sure
# style is there and the same
s2 = m.find_style('s')
rules = s2.rules
eq_(len(rules), 1)
r2 = rules[0]
syms = r2.symbols
eq_(len(syms), 1)
# TODO here, we can do...
sym = syms[0]
p2 = sym.extract()
assert isinstance(p2, mapnik.PointSymbolizer)
eq_(p2.allow_overlap, True)
eq_(p2.opacity, 0.5)
eq_(p2.filename, '../data/images/dummy.png')
# Make sure that extract() does not copy
# the symbolizer object
# Take new reference
p3 = sym.extract()
# Modify the object through the old reference
p2.allow_overlap = False
p2.opacity = 1.0
p2.file = '../data/images/xxx.png'
eq_(p2.allow_overlap, p3.allow_overlap)
eq_(p2.opacity, p3.opacity)
eq_(p2.file, p3.file)
def test_pointsymbolizer_pickle():
raise Todo("point_symbolizer pickling currently disabled")
p = mapnik.PointSymbolizer(
mapnik.PathExpression("../data/images/dummy.png"))
p2 = pickle.loads(pickle.dumps(p, pickle.HIGHEST_PROTOCOL))
# image type, width, and height only used in contructor...
eq_(p.filename, p2.filename)
eq_(p.allow_overlap, p2.allow_overlap)
eq_(p.opacity, p2.opacity)
eq_(p.ignore_placement, p2.ignore_placement)
eq_(p.placement, p2.placement)
def test_introspect_symbolizers():
# create a symbolizer
p = mapnik.PointSymbolizer(
mapnik.PathExpression("../data/images/dummy.png"))
p.allow_overlap = True
p.opacity = 0.5
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.filename, '../data/images/dummy.png')
# make sure the defaults
# are what we think they are
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.filename, '../data/images/dummy.png')
# contruct objects to hold it
r = mapnik.Rule()
r.symbols.append(p)
s = mapnik.Style()
s.rules.append(r)
m = mapnik.Map(0, 0)
m.append_style('s', s)
# try to figure out what is
# in the map and make sure
# style is there and the same
s2 = m.find_style('s')
rules = s2.rules
eq_(len(rules), 1)
r2 = rules[0]
syms = r2.symbols
eq_(len(syms), 1)
## TODO here, we can do...
sym = syms[0]
# this is hackish at best
p2 = sym.symbol()
assert isinstance(p2, mapnik.PointSymbolizer)
eq_(p2.allow_overlap, True)
eq_(p2.opacity, 0.5)
eq_(p2.filename, '../data/images/dummy.png')
## but we need to be able to do:
p2 = syms[0] # get the actual symbolizer, not the variant object
# this will throw for now...
assert isinstance(p2, mapnik.PointSymbolizer)
eq_(p2.allow_overlap, True)
eq_(p2.opacity, 0.5)
eq_(p2.filename, '../data/images/dummy.png')
def test_point_symbolizer():
p = mapnik.PointSymbolizer()
eq_(p.filename,'')
eq_(p.transform,'')
eq_(p.opacity,1.0)
eq_(p.allow_overlap,False)
eq_(p.ignore_placement,False)
eq_(p.comp_op,mapnik.CompositeOp.src_over)
eq_(p.placement, mapnik.point_placement.CENTROID)
p = mapnik.PointSymbolizer(mapnik.PathExpression("../data/images/dummy.png"))
p.allow_overlap = True
p.opacity = 0.5
p.ignore_placement = True
p.placement = mapnik.point_placement.INTERIOR
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.filename,'../data/images/dummy.png')
eq_(p.ignore_placement,True)
eq_(p.placement, mapnik.point_placement.INTERIOR)
def test_render_points():
if not mapnik.has_cairo(): return
# create and populate point datasource (WGS84 lat-lon coordinates)
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push('Name')
f = mapnik.Feature(context, 1)
f['Name'] = 'Westernmost Point'
f.add_geometries_from_wkt('POINT (142.48 -38.38)')
ds.add_feature(f)
f = mapnik.Feature(context, 2)
f['Name'] = 'Southernmost Point'
f.add_geometries_from_wkt('POINT (143.10 -38.60)')
ds.add_feature(f)
# create layer/rule/style
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.PointSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places', '+proj=latlon +datum=WGS84')
lyr.datasource = ds
lyr.styles.append('places_labels')
# latlon bounding box corners
ul_lonlat = mapnik.Coord(142.30, -38.20)
lr_lonlat = mapnik.Coord(143.40, -38.80)
# render for different projections
projs = {
'latlon': '+proj=latlon +datum=WGS84',
'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
'google': '+proj=merc +ellps=sphere +R=6378137 +a=6378137 +units=m',
'utm': '+proj=utm +zone=54 +datum=WGS84'
}
for projdescr in projs.iterkeys():
m = mapnik.Map(1000, 500, projs[projdescr])
m.append_style('places_labels', s)
m.layers.append(lyr)
p = mapnik.Projection(projs[projdescr])
m.zoom_to_box(p.forward(mapnik.Box2d(ul_lonlat, lr_lonlat)))
# Render to SVG so that it can be checked how many points are there with string comparison
svg_file = os.path.join(tempfile.gettempdir(), '%s.svg')
mapnik.render_to_file(m, svg_file)
num_points_present = len(ds.all_features())
svg = open(svg_file, 'r').read()
num_points_rendered = svg.count('<image ')
eq_(
num_points_present, num_points_rendered,
"Not all points were rendered (%d instead of %d) at projection %s"
% (num_points_rendered, num_points_present, projdescr))
def default_style():
default_style = mapnik.Style()
ps = mapnik.PolygonSymbolizer(mapnik.Color('#ffffff'))
ps.fill_opacity = 0.5
ls = mapnik.LineSymbolizer(mapnik.Color('#555555'), 0.75)
ls.stroke_opacity = 0.5
r = mapnik.Rule()
r.symbols.append(ps)
r.symbols.append(ls)
r.symbols.append(mapnik.PointSymbolizer())
default_style.rules.append(r)
return default_style
def test_point_symbolizer_grid():
width,height = 256,256
sym = mapnik.PointSymbolizer()
sym.file = '../data/images/dummy.png'
m = create_grid_map(width,height,sym)
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
grid = mapnik.Grid(m.width,m.height)
mapnik.render_layer(m,grid,layer=0,fields=['Name'])
utf1 = grid.encode()
eq_(utf1,point_expected,show_grids('point-sym',utf1,point_expected))
def get_default_style(geometry_type):
""" Ultra simple default style for quick setup or debugging.
"""
style, rule = mapnik.Style(), mapnik.Rule()
gtype = geometry_type.lower()
if 'poly' in gtype:
rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('steelblue')))
rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color('steelblue'),.5))
elif 'line' in gtype:
rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color('steelblue'),1.5))
else:
point = mapnik.PointSymbolizer()
point.allow_overlap = True
rule.symbols.append(point)
style.rules.append(rule)
return style
def _get_map(self, normalized_args):
"""Return the Mapnik object (with hardcoded symbology/rule)."""
# miss:
# bgcolor
# exceptions
projection = parse_projection(normalized_args)
# validate projection
size = parse_size(normalized_args)
mp = mapnik.Map(size.width, size.height, "+init=" + projection)
# TODO: how do we manage style ? just have hardcoded
# style list in a dir ?
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(mapnik.RasterSymbolizer())
s.rules.append(r)
r.symbols.append(mapnik.PointSymbolizer())
s.rules.append(r)
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color("black")
polygon_symbolizer.fill_opacity = 0
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color("black")
line_symbolizer.stroke_width = 1.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
style_name = "My Style"
mp.append_style(style_name, s)
# TODO read the background set it
# mp.background_color = 'steelblue'
layer_names = parse_layers(normalized_args)
for layer_name in layer_names:
try:
layer = geofile.load(layer_name)
except FileNotFoundError as e:
abort(404, e.strerror)
mapnik_layer = layer.as_mapnik_layer()
mapnik_layer.styles.append(style_name)
mp.layers.append(mapnik_layer)
return mp
def create_symbolizer(datasource):
"""
symbolizer fabric for various types of shape
"""
geom_type = datasource.geometry_type()
if geom_type == DataGeometryType.Point:
symbolizer = mapnik.PointSymbolizer()
elif geom_type == DataGeometryType.Polygon:
symbolizer = mapnik.PolygonSymbolizer()
elif geom_type == DataGeometryType.LineString:
symbolizer = mapnik.LineSymbolizer()
elif geom_type == DataGeometryType.Collection:
symbolizer = mapnik.LineSymbolizer()
else:
msg = 'Invalid geomerty type of object %s' % datasource
raise GeometryTypeError(msg)
return symbolizer
def __init__(self):
BaseWMSFactory.__init__(self)
name = "photos"
title = "Geo-tagged photos"
select = "photos"
select = '''(SELECT kmeans, count(*), ST_Centroid(ST_Collect(point)) AS point
FROM (
SELECT kmeans(ARRAY[ST_X(point), ST_Y(point)], 100) OVER (), point
FROM photos WHERE point is not NULL
) AS ksub
GROUP BY kmeans
ORDER BY kmeans) as result '''
select = '''(SELECT kmeans, count(*), ST_ConvexHull(ST_Collect(point)) AS point
FROM (
SELECT kmeans(ARRAY[ST_X(point), ST_Y(point)], 100) OVER (), point
FROM photos WHERE point is not NULL
) AS ksub
GROUP BY kmeans
ORDER BY kmeans) as result '''
layer = mapnik.Layer(name,"+init=epsg:4326")
layer.datasource = mapnik.PostGIS(host='localhost',
user='******',
password='******',
dbname='remotesensing',
table=select)
layer.title = title
layer.queryable = True
layer.wms_srs = None
style = mapnik.Style()
rule = mapnik.Rule()
#icon = "/web/eomf/dev/eomf/photos/circle.svg"
sym = mapnik.PointSymbolizer()
sym2 = mapnik.PolygonSymbolizer()
#sym.filename = "/web/eomf/dev/eomf/photos/circle.svg"
sym.allow_overlap = True
sym.opacity = .5
rule.symbols.append(sym)
rule.symbols.append(sym2)
style.rules.append(rule)
self.register_style(name,style)
self.register_layer(layer, name, (name,))
self.finalize()
def style(self):
"""
Make mapnik point style
"""
symbol_manager = SymbolManager(
ICON_ORIGINALS, os.path.join(settings.MEDIA_ROOT,
'generated_icons'))
output_filename = symbol_manager.get_symbol_transformed(
ICON_STYLE['icon'], **ICON_STYLE)
output_filename_abs = os.path.join(settings.MEDIA_ROOT,
'generated_icons', output_filename)
point_looks = mapnik.PointSymbolizer()
point_looks.filename = output_filename_abs
point_looks.allow_overlap = True
layout_rule = mapnik.Rule()
layout_rule.symbols.append(point_looks)
point_style = mapnik.Style()
point_style.rules.append(layout_rule)
return point_style
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 render(self, **kwargs):
m = mapnik.Map(kwargs['width'], kwargs['height'], '+init=epsg:' + str(kwargs['epsg']))
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(str(kwargs['color'])))
polygon_symbolizer.fill_opacity = kwargs['opacity']
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'), 1.0)
r.symbols.append(line_symbolizer)
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Ogr(string=json.dumps(kwargs['geojson']), layer='OGRGeoJSON')
layer = mapnik.Layer('wkt', '+init=epsg:' + str(kwargs['epsg']))
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
extent = mapnik.Box2d(kwargs['bbox'][0], kwargs['bbox'][1], kwargs['bbox'][2], kwargs['bbox'][3])
m.zoom_to_box(extent)
mapnik.render_to_file(m, str(kwargs['filename']), str(kwargs['filetype']))
def index(request):
m = mapnik.Map(1240, 720)
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)
highlight = mapnik.PointSymbolizer()
highlight.file='mapnikApp/static/images/point.png'
highlight.allow_overlap="yes"
countryList = ['India', 'United Kingdom', 'United States', 'Canada']
for i in range(0, len(countryList)):
countryName = mapnik.Rule()
countryName.filter = mapnik.Expression("[name]='{}'".format(countryList[i]))
countryName.symbols.append(highlight)
s.rules.append(countryName)
m.append_style('Borders', s)
query = "(SELECT * FROM worldborders) AS data"
ds = mapnik.PostGIS(dbname="temp", user="******", table=query)
layer = mapnik.Layer("world")
layer.datasource = ds
layer.styles.append("Borders")
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, "mapnikApp/static/images/temp.png", "png")
return render(request, "mapnikIndex.html")
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
def tileLayer(request, version, shapefile_id, zoom, x, y):
try:
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id,
created_by=request.user)
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)
yExtent = _unitsPerPixel(zoom)
minLong = x * xExtent - 20037508.34
minLat = y * yExtent - 20037508.34
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -20037508.34 or maxLong > 20037508.34
or minLat < -20037508.34 or maxLat > 20037508.34):
raise Http404
#create de mapnik.map object
map = 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"
)
map.background = mapnik.Color("#f2f3f7")
#defining the feature layer
geometryField = utils.calcGeometryField(shapefile.geom_type)
field = "'NOM'"
field2 = "'CODE'"
query = '(select ' + geometryField + ', attribute_value->' + field + ' as label, id_relat from "shapefile_feature" where' + ' shapefile_id in (' + str(
shapefile.id) + ')) as geom'
## datasource = mapnik.SQLite(file='C:\mygeosite\sqlite3\sql3.db',
## table=query,
## srid=3857,
## geometry_field=geometryField)
## datasource = mapnik.PostGIS(user=dbSettings['USER'],
## password=dbSettings['PASSWORD'],
## dbname=dbSettings['NAME'],
## table=query,
## srid=3857,
## geometry_field=geometryField,
## simplify_geometries=True,
## geometry_table='"shapefile_feature"')
feature = Feature.objects.filter(shapefile__id=shapefile_id).geojson()
geoj = feature.geojson
datasource = mapnik.Ogr(layer_by_index=0, string=geoj)
##
featureLayer = mapnik.Layer("featureLayer")
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.styles.append("featureLayerStyle")
#defining the feature layer styles
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))
## label = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Book', 10, mapnik.Color('black'))
## label.halo_fill = mapnik.Color('white')
## label.halo_radius = 4
## label.label_placement = mapnik.label_placement.INTERIOR_PLACEMENT
## label.allow_overlap = True
## label.avoid_edges = True
## rule.symbols.append(label)
style = mapnik.Style()
style.rules.append(rule)
#add new feature to the map
map.append_style("featureLayerStyle", style)
map.layers.append(featureLayer)
#rendering the map tile
mapnik.save_map(
map, "../tilestache/%s/%s.xml" %
(str(request.user), str(shapefile.filename)))
config = {
"cache": {
"name": "Test",
"path": "../tilestache/%s" % (request.user),
"umask": "0000",
"dirs": "portable"
},
"layers": {
shapefile.filename: {
"provider": {
"name":
"mapnik",
"mapfile":
"../tilestache/%s/%s.xml" %
(request.user, shapefile.filename)
},
"projection": "spherical mercator"
}
}
}
# like http://tile.openstreetmap.org/1/0/0.png
#coord = ModestMaps.Core.Coordinate(y, x, zoom)
path = "/%s/%s/%s/%s.png" % (shapefile.filename, zoom, x, y)
config = TileStache.Config.buildConfiguration(config)
#type, bytes = TileStache.getTile(config.layers[shapefile.filename], coord, 'png')
type, bytes = TileStache.requestHandler(config, path)
return HttpResponse(bytes, mimetype="image/png")
except:
traceback.print_exc()
return HttpResponse("")
