def create_grid_map(width,height):
places_ds = mapnik.PointDatasource()
places_ds.add_point(143.10,-38.60,'Name','South East')
places_ds.add_point(142.48,-38.60,'Name','South West')
places_ds.add_point(142.48,-38.38,'Name','North West')
places_ds.add_point(143.10,-38.38,'Name','North East')
s = mapnik.Style()
r = mapnik.Rule()
#symb = mapnik.PointSymbolizer()
symb = mapnik.MarkersSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
label = mapnik.TextSymbolizer(mapnik.Expression('[Name]'),
'DejaVu Sans Book',
10,
mapnik.Color('black')
)
label.allow_overlap = True
label.displacement = (0,-10)
#r.symbols.append(label)
s.rules.append(r)
lyr = mapnik.Layer('Places')
lyr.datasource = places_ds
lyr.styles.append('places_labels')
m = mapnik.Map(width,height)
m.append_style('places_labels',s)
m.layers.append(lyr)
return m
def create_rule(expression, color):
rule = mapnik.Rule()
rule.filter = mapnik.Expression(expression)
point_symbolizer = mapnik.MarkersSymbolizer()
point_symbolizer.fill = mapnik.Color(*color)
rule.symbols.append(point_symbolizer)
return rule
def init_map(zoom, seq):
m = mapnik.Map(256, 256, merc_srs)
m.background_color = mapnik.Color('white')
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.MarkersSymbolizer()
sym.fill = mapnik.Color('black')
sym.spacing = 0.0
sym.opacity = opacity(zoom)
sym.height = mapnik.Expression(str(pointWeight(zoom) / 2.0))
sym.width = mapnik.Expression(str(pointWeight(zoom) / 2.0))
# Ignore placement instructs Mapnik to avoid building the quadtree
# collision cache and helps performance if you know you want to
# allow for overlaps between features.
# - Dane
sym.allow_overlap = True
sym.ignore_placement = True
r.symbols.append(sym)
s.rules.append(r)
m.append_style('point_style', s)
TuplesDatasource.set_source(seq)
ds = mapnik.Python(factory='TuplesDatasource')
layer = mapnik.Layer('file', merc_srs)
layer.datasource = ds
layer.styles.append('point_style')
m.layers.append(layer)
return m
def test_render_grid3():
""" test using feature id"""
width,height = 256,256
sym = mapnik.MarkersSymbolizer()
sym.width = mapnik.Expression('10')
sym.height = mapnik.Expression('10')
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,key='__id__')
mapnik.render_layer(m,grid,layer=0,fields=['__id__','Name'])
utf1 = grid.encode('utf',resolution=4)
eq_(utf1,grid_feat_id3,show_grids('id-markers',utf1,grid_feat_id3))
# check a full view is the same as a full image
grid_view = grid.view(0,0,width,height)
# for kicks check at full res too
utf3 = grid.encode('utf',resolution=1)
utf4 = grid_view.encode('utf',resolution=1)
eq_(utf3['grid'],utf4['grid'])
eq_(utf3['keys'],utf4['keys'])
eq_(utf3['data'],utf4['data'])
eq_(resolve(utf4,0,0),None)
# resolve some center points in the
# resampled view
utf5 = grid_view.encode('utf',resolution=4)
eq_(resolve(utf5,25,10),{"Name": "North West","__id__": 3})
eq_(resolve(utf5,25,46),{"Name": "North East","__id__": 4})
eq_(resolve(utf5,38,10),{"Name": "South West","__id__": 2})
eq_(resolve(utf5,38,46),{"Name": "South East","__id__": 1})
def test_render_grid():
places_ds = mapnik.PointDatasource()
places_ds.add_point(143.10,-38.60,'Name','South East')
places_ds.add_point(142.48,-38.60,'Name','South West')
places_ds.add_point(142.48,-38.38,'Name','North West')
places_ds.add_point(143.10,-38.38,'Name','North East')
s = mapnik.Style()
r = mapnik.Rule()
#symb = mapnik.PointSymbolizer()
symb = mapnik.MarkersSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
label = mapnik.TextSymbolizer(mapnik.Expression('[Name]'),
'DejaVu Sans Book',
10,
mapnik.Color('black')
)
label.allow_overlap = True
label.displacement = (0,-10)
#r.symbols.append(label)
s.rules.append(r)
lyr = mapnik.Layer('Places')
lyr.datasource = places_ds
lyr.styles.append('places_labels')
m = mapnik.Map(256,256)
m.append_style('places_labels',s)
m.layers.append(lyr)
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.render_grid(m,0,key='Name',resolution=4,fields=['Name'])
eq_(grid,grid_correct)
eq_(resolve(grid,0,0),None)
# check every pixel of the nw symbol
expected = {"Name": "North West"}
# top row
eq_(resolve(grid,23,9),expected)
eq_(resolve(grid,23,10),expected)
eq_(resolve(grid,23,11),expected)
# core
eq_(resolve(grid,24,8),expected)
eq_(resolve(grid,24,9),expected)
eq_(resolve(grid,24,10),expected)
eq_(resolve(grid,24,11),expected)
eq_(resolve(grid,24,12),expected)
eq_(resolve(grid,25,8),expected)
eq_(resolve(grid,25,9),expected)
eq_(resolve(grid,25,10),expected)
eq_(resolve(grid,25,11),expected)
eq_(resolve(grid,25,12),expected)
# bottom row
eq_(resolve(grid,26,9),expected)
eq_(resolve(grid,26,10),expected)
eq_(resolve(grid,26,11),expected)
def createIntersectionStyle():
style = mapnik.Style()
rule = mapnik.Rule()
point_symbolizer = mapnik.MarkersSymbolizer()
point_symbolizer.allow_overlap = True
point_symbolizer.opacity = 0.5
rule.symbols.append(point_symbolizer)
style.rules.append(rule)
return style
def point(color=None, stroke=None):
symbolizer = mapnik.MarkersSymbolizer()
symbolizer.transform = 'scale(0.3, 0.3)'
if color is not None:
symbolizer.fill = color
if stroke is not None:
symbolizer.stroke = stroke
symbolizer.allow_overlap = True
return symbolizer
def icon(file, transform=None, color=None, allowOverlap=False):
symbolizer = mapnik.MarkersSymbolizer()
symbolizer.filename = file
symbolizer.allow_overlap = allowOverlap
if color is not None:
symbolizer.fill = color
if transform is not None:
symbolizer.transform = transform
return symbolizer
def test_markers_symbolizer():
p = mapnik.MarkersSymbolizer()
eq_(p.allow_overlap, False)
eq_(p.opacity,1.0)
eq_(p.fill_opacity,None)
eq_(p.filename,'shape://ellipse')
eq_(p.placement,mapnik.marker_placement.POINT_PLACEMENT)
eq_(p.multi_policy,mapnik.marker_multi_policy.EACH)
eq_(p.fill,None)
eq_(p.ignore_placement,False)
eq_(p.spacing,100)
eq_(p.max_error,0.2)
eq_(p.width,None)
eq_(p.height,None)
eq_(p.transform,'')
eq_(p.clip,True)
eq_(p.comp_op,mapnik.CompositeOp.src_over)
p.width = mapnik.Expression('12')
p.height = mapnik.Expression('12')
eq_(str(p.width),'12')
eq_(str(p.height),'12')
p.width = mapnik.Expression('[field] + 2')
p.height = mapnik.Expression('[field] + 2')
eq_(str(p.width),'([field]+2)')
eq_(str(p.height),'([field]+2)')
stroke = mapnik.Stroke()
stroke.color = mapnik.Color('black')
stroke.width = 1.0
p.stroke = stroke
p.fill = mapnik.Color('white')
p.allow_overlap = True
p.opacity = 0.5
p.fill_opacity = 0.5
p.placement = mapnik.marker_placement.LINE_PLACEMENT
p.multi_policy = mapnik.marker_multi_policy.WHOLE
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
eq_(p.fill_opacity, 0.5)
eq_(p.multi_policy,mapnik.marker_multi_policy.WHOLE)
eq_(p.placement,mapnik.marker_placement.LINE_PLACEMENT)
#https://github.com/mapnik/mapnik/issues/1285
#https://github.com/mapnik/mapnik/issues/1427
p.marker_type = 'arrow'
eq_(p.marker_type,'shape://arrow')
eq_(p.filename,'shape://arrow')
def getPointStyle():
# add style
style = mapnik.Style() # style object to hold rules
rule = mapnik.Rule() # rule object to hold symbolizers
marker = mapnik.MarkersSymbolizer()
# marker.fill_opacity = .5
# marker.opacity = .5
marker.height = mapnik.Expression("3")
marker.width = mapnik.Expression("3")
marker.fill = mapnik.Color('black')
rule.symbols.append(marker)
style.rules.append(rule)
return style
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_render_with_detector():
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
geojson = '{ "type": "Feature", "geometry": { "type": "Point", "coordinates": [ 0, 0 ] } }'
ds.add_feature(mapnik.Feature.from_geojson(geojson, context))
s = mapnik.Style()
r = mapnik.Rule()
lyr = mapnik.Layer('point')
lyr.datasource = ds
lyr.styles.append('point')
symb = mapnik.MarkersSymbolizer()
symb.allow_overlap = False
r.symbols.append(symb)
s.rules.append(r)
m = mapnik.Map(256, 256)
m.append_style('point', s)
m.layers.append(lyr)
m.zoom_to_box(mapnik.Box2d(-180, -85, 180, 85))
im = mapnik.Image(256, 256)
mapnik.render(m, im)
expected_file = './images/support/marker-in-center.png'
actual_file = '/tmp/' + os.path.basename(expected_file)
#im.save(expected_file,'png8')
im.save(actual_file, 'png8')
actual = mapnik.Image.open(expected_file)
expected = mapnik.Image.open(expected_file)
eq_(
actual.tostring('png32'), expected.tostring('png32'),
'failed comparing actual (%s) and expected (%s)' %
(actual_file, expected_file))
# now render will a collision detector that should
# block out the placement of this point
detector = mapnik.LabelCollisionDetector(m)
eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, m.width, m.height))
eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, 256.0, 256.0))
eq_(detector.boxes(), [])
detector.insert(detector.extent())
eq_(detector.boxes(), [detector.extent()])
im2 = mapnik.Image(256, 256)
mapnik.render_with_detector(m, im2, detector)
expected_file_collision = './images/support/marker-in-center-not-placed.png'
#im2.save(expected_file_collision,'png8')
actual_file = '/tmp/' + os.path.basename(expected_file_collision)
im2.save(actual_file, 'png8')
def test_render_to_grid_multiple_times():
# create map with two layers
m = mapnik.Map(256,256)
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.MarkersSymbolizer()
sym.allow_overlap = True
r.symbols.append(sym)
s.rules.append(r)
m.append_style('points',s)
# NOTE: we use a csv datasource here
# because the memorydatasource fails silently for
# queries requesting fields that do not exist in the datasource
ds1 = mapnik.Datasource(**{"type":"csv","inline":'''
wkt,Name
"POINT (143.10 -38.60)",South East'''})
lyr1 = mapnik.Layer('One')
lyr1.datasource = ds1
lyr1.styles.append('points')
m.layers.append(lyr1)
ds2 = mapnik.Datasource(**{"type":"csv","inline":'''
wkt,Value
"POINT (142.48 -38.60)",South West'''})
lyr2 = mapnik.Layer('Two')
lyr2.datasource = ds2
lyr2.styles.append('points')
m.layers.append(lyr2)
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'])
# should throw right here since Name will be a property now on the `grid` object
# and it is not found on the second layer
mapnik.render_layer(m,grid,layer=1,fields=['Value'])
grid.encode()
def make_tmp_map():
m = mapnik.Map(512,512)
m.background_color = mapnik.Color('steelblue')
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push('Name')
f = mapnik.Feature(context,1)
f['Name'] = 'Hello'
f.add_geometries_from_wkt('POINT (0 0)')
ds.add_feature(f)
s = mapnik.Style()
r = mapnik.Rule()
sym = mapnik.MarkersSymbolizer()
sym.allow_overlap = True
r.symbols.append(sym)
s.rules.append(r)
lyr = mapnik.Layer('Layer')
lyr.datasource = ds
lyr.styles.append('style')
m.append_style('style',s)
m.layers.append(lyr)
return m
def __init__(self, id, config):
self.id = id
client = pymongo.MongoClient()
self.db = client.tiles
self.db.tiles.ensure_index([("id", pymongo.ASCENDING),
("xyz", pymongo.ASCENDING)])
buf = BytesIO()
im = PIL.Image.new("RGBA", (256, 256))
im.save(buf, "png")
self.blanksize = buf.__sizeof__()
print "Blank size: %i" % (self.blanksize)
self.db.blank.drop()
self.db.blank.insert_one({"tile": Binary(buf.getvalue())})
self.datasource = mapnik.PostGIS(
host=config.host,
user=config.user,
password=config.password,
dbname="obis",
table=
"(select geom from explore.points where species_id = %s) points" %
(self.id),
geometry_field="geom",
srid="4326",
extent="%s, %s, %s, %s" % (-180, -90, 180, 90),
connext_timeout=10)
self.style = mapnik.Style()
rule = mapnik.Rule()
symbolizer = mapnik.MarkersSymbolizer()
symbolizer.width = 5.0
symbolizer.stroke_width = 0.0
symbolizer.fill = mapnik.Color("#ff0000")
symbolizer.opacity = 1.0
symbolizer.allow_overlap = mapnik.Expression("True")
rule.symbols.append(symbolizer)
self.style.rules.append(rule)
def test_markersymbolizer_init():
p = mapnik.MarkersSymbolizer()
eq_(p.allow_overlap, False)
eq_(p.opacity, 1)
eq_(p.filename, '')
eq_(p.marker_type, mapnik.marker_type.ARROW)
eq_(p.placement, mapnik.marker_placement.LINE_PLACEMENT)
eq_(p.fill, mapnik.Color(0, 0, 255))
eq_(p.ignore_placement, False)
eq_(p.spacing, 100)
eq_(p.max_error, 0.2)
stroke = mapnik.Stroke()
stroke.color = mapnik.Color('black')
stroke.width = 1.0
p.stroke = stroke
p.fill = mapnik.Color('white')
p.allow_overlap = True
p.opacity = 0.5
eq_(p.allow_overlap, True)
eq_(p.opacity, 0.5)
tile_request_pat = r'/(?P<version>\d{1,2}\.\d{1,3}\.\d{1,3})/(?P<layername>[a-z]{1,64})/(?P<z>\d{1,10})/(?P<x>\d{1,10})/(?P<y>\d{1,10})\.(?P<extension>(?:png|jpg|gif))'
# hackish way to grab style obj and avoid parsing XML each request...
m = mapnik.Map(1, 1)
mapnik.load_map(m, settings.MAPNIK_STYLESHEET)
style = m.find_style('style')
del m
style2 = mapnik.Style()
r = mapnik.Rule()
icon = '/ebs/projects/oakland/OpenTreeMap/static/images/SanDiego/map_icons/v4/marker-sm.png'
sym = mapnik.PointSymbolizer(mapnik.PathExpression(icon))
sym.transform = 'scale(0.4)'
sym.allow_overlap = True
sym.opacity = .5
x = mapnik.MarkersSymbolizer()
x.width = mapnik.Expression("20")
x.stroke_width = mapnik.Expression("20")
x.allow_overlap = True
x.fill = '#ff0'
x.stroke = '#ccc'
r.symbols.append(sym)
style2.rules.append(r)
srv = None
if settings.CACHE_SEARCH_METHOD == 'mem':
srv = Service(
Memcached(),
{}, # layers are dynamic
)
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)
def test_render_grid():
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push('Name')
f = mapnik.Feature(context,1)
f['Name'] = 'South East'
f.add_geometries_from_wkt('POINT (143.10 -38.60)')
ds.add_feature(f)
f = mapnik.Feature(context,2)
f['Name'] = 'South West'
f.add_geometries_from_wkt('POINT (142.48 -38.60)')
ds.add_feature(f)
f = mapnik.Feature(context,3)
f['Name'] = 'North West'
f.add_geometries_from_wkt('POINT (142.48 -38.38)')
ds.add_feature(f)
f = mapnik.Feature(context,4)
f['Name'] = 'North East'
f.add_geometries_from_wkt('POINT (143.10 -38.38)')
ds.add_feature(f)
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.MarkersSymbolizer()
symb.width = 10
symb.height = 10
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places')
lyr.datasource = ds
lyr.styles.append('places_labels')
m = mapnik.Map(256,256)
m.append_style('places_labels',s)
m.layers.append(lyr)
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.render_grid(m,0,key='Name',resolution=4,fields=['Name'])
eq_(grid,grid_correct)
eq_(resolve(grid,0,0),None)
# check every pixel of the nw symbol
expected = {"Name": "North West"}
# top row
eq_(resolve(grid,23,9),expected)
eq_(resolve(grid,23,10),expected)
eq_(resolve(grid,23,11),expected)
# core
eq_(resolve(grid,24,8),expected)
eq_(resolve(grid,24,9),expected)
eq_(resolve(grid,24,10),expected)
eq_(resolve(grid,24,11),expected)
eq_(resolve(grid,24,12),expected)
eq_(resolve(grid,25,8),expected)
eq_(resolve(grid,25,9),expected)
eq_(resolve(grid,25,10),expected)
eq_(resolve(grid,25,11),expected)
eq_(resolve(grid,25,12),expected)
# bottom row
eq_(resolve(grid,26,9),expected)
eq_(resolve(grid,26,10),expected)
eq_(resolve(grid,26,11),expected)
pnt.style.iconstyle.icon.href = 'http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png'
kml.save('/picmap/out/kml_geo.kml')
width_in_px = 4000
height_in_px = width_in_px / 2
mapfile = '/picmap/map-assets/mapnik_style.xml'
map_canvas = mapnik.Map(width_in_px, height_in_px)
mapnik.load_map(map_canvas, mapfile)
map_canvas.background = mapnik.Color('rgb(0,0,0,0)') # transparent
# Create a symbolizer to draw the points
style = mapnik.Style()
rule = mapnik.Rule()
point_symbolizer = mapnik.MarkersSymbolizer()
point_symbolizer.allow_overlap = True
point_symbolizer.opacity = 1.0 # semi-transparent
rule.symbols.append(point_symbolizer)
style.rules.append(rule)
map_canvas.append_style('GPS_tracking_points', style)
# Create a layer to hold the ponts
layer = mapnik.Layer('GPS_tracking_points')
layer.datasource = mapnik.Ogr(file="/picmap/out/kml_geo.kml",
layer_by_index=0)
layer.styles.append('GPS_tracking_points')
map_canvas.layers.append(layer)
# Save the map
map_canvas.zoom_all()
#Membuat poligon area
rsby = mapnik.Rule()
polygon_sby = mapnik.PolygonSymbolizer(mapnik.Color(217, 235, 203))
rsby.symbols.append(polygon_sby) #membuat rule polygon indonesia
#Menggambar garis tepi
#line_sby = mapnik.LineSymbolizer()
#line_sby = mapnik.LineSymbolizer(mapnik.Color('grey'),1)
#line_sby.stroke_width = 2.0
#rsby.symbols.append(line_sby) #menerapkan garis tepi ke rule map
#Poin wisata
ssby_wisata = mapnik.Style()
rsby_wisata = mapnik.Rule()
poin_wisata = mapnik.MarkersSymbolizer()
poin_wisata.filename = 'beach.png'
poin_wisata.width = mapnik.Expression('20')
poin_wisata.height = mapnik.Expression('20')
poin_wisata.allow_overlap = True
rsby_wisata.symbols.append(poin_wisata) #membuat rule poin_wisata
label = mapnik.TextSymbolizer(mapnik.Expression('[Kecamatan]'),
'DejaVu Sans Book', 5, mapnik.Color('Red'))
label.halo_radius = 1
label.avoid_edges = False
rsby_wisata.symbols.append(label) #membuat rule label
#Membuat Layer Tempat Wisata
layer_wisata = mapnik.Layer('Wisata', '+init=epsg:4326')
ds = mapnik.MemoryDatasource()
