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 addShapeSingleSymbole(self, fName, name=None):
if name is None:
name = str.split(fName, ".")[0]
clr = self.randomColor()
ds = mapnik.Shapefile(file=fName)
lyr = mapnik.Layer(name)
lyr.datasource = ds
geomType = str(ds.geometry_type())
if geomType in ["Point", "MultiPoint"]:
s = self.singlePointStyle(mapnik.PathExpression("Icons/point.png"),
0.1)
elif geomType in ["LineString", "MultiLineString", "Line"]:
s = self.singleLineStyle(clr, 0.5)
elif geomType in ["Polygon", "MultiPolygon"]:
s = self.singlePolyStyle(clr)
prjFile = fName.rsplit(".", 1)[0] + '.prj'
prj = self.esriprj2standards(prjFile)
if len(self.map.layers) == 0 and prj != '':
self.map.srs = prj
if prj != '': lyr.srs = prj
self.map.append_style(name, s)
lyr.styles.append(name)
self.map.layers.append(lyr)
#self.mapLayers.append(self.readOgrShape(fName))
self.mapLayers[name] = geomType
self.map.resize(self.width(), self.height())
return [name, clr, geomType]
def test_line_pattern():
s = mapnik.LinePatternSymbolizer(mapnik.PathExpression('../data/images/dummy.png'))
eq_(s.filename, '../data/images/dummy.png')
eq_(s.smooth,0.0)
eq_(s.transform,'')
eq_(s.comp_op,mapnik.CompositeOp.src_over)
eq_(s.clip,True)
def test_shieldsymbolizer_modify():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
# transform expression
s.transform = "rotate(30+[a]) scale(2*[sx] [sy])"
eq_(s.transform, "rotate((30+[a])) scale(2*[sx], [sy])")
def test_shieldsymbolizer_init():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
eq_(s.anchor, (
0.0,
0.5,
))
eq_(s.displacement, (0.0, 0.0))
eq_(s.allow_overlap, False)
eq_(s.avoid_edges, False)
eq_(s.character_spacing, 0)
eq_(str(s.name), str(mapnik.Expression('[Field Name]')))
eq_(s.face_name, 'DejaVu Sans Bold')
eq_(s.allow_overlap, False)
eq_(s.fill, mapnik.Color('#000000'))
eq_(s.force_odd_labels, False)
eq_(s.halo_fill, mapnik.Color('rgb(255,255,255)'))
eq_(s.halo_radius, 0)
eq_(s.label_placement, mapnik.label_placement.POINT_PLACEMENT)
eq_(s.minimum_distance, 0.0)
eq_(s.text_ratio, 0)
eq_(s.text_size, 6)
eq_(s.wrap_width, 0)
eq_(s.vertical_alignment, mapnik.vertical_alignment.MIDDLE)
eq_(s.label_spacing, 0)
eq_(s.label_position_tolerance, 0)
# 22.5 * M_PI/180.0 initialized by default
assert_almost_equal(s.max_char_angle_delta, 0.39269908169872414)
eq_(s.wrap_character, ' ')
eq_(s.text_transform, mapnik.text_transform.NONE)
eq_(s.line_spacing, 0)
eq_(s.character_spacing, 0)
# r1341
eq_(s.wrap_before, False)
eq_(s.horizontal_alignment, mapnik.horizontal_alignment.MIDDLE)
eq_(s.justify_alignment, mapnik.justify_alignment.MIDDLE)
eq_(s.opacity, 1.0)
# r2300
eq_(s.minimum_padding, 0.0)
# was mixed with s.opacity
eq_(s.text_opacity, 1.0)
eq_(s.shield_displacement, (0.0, 0.0))
# TODO - the pattern in bindings seems to be to get/set
# strings for PathExpressions... should we pass objects?
eq_(s.filename, '../data/images/dummy.png')
eq_(s.transform, 'matrix(1, 0, 0, 1, 0, 0)')
raise Todo(
"FontSet pickling support needed: http://trac.mapnik.org/ticket/348")
eq_(s.fontset, '')
def test_shield_symbolizer_init():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
eq_(s.comp_op, mapnik.CompositeOp.src_over)
eq_(s.clip, True)
eq_(s.displacement, (0.0, 0.0))
eq_(s.allow_overlap, False)
eq_(s.avoid_edges, False)
eq_(s.character_spacing, 0)
#eq_(str(s.name), str(mapnik2.Expression('[Field Name]'))) name field is no longer supported
eq_(s.face_name, 'DejaVu Sans Bold')
eq_(s.allow_overlap, False)
eq_(s.fill, mapnik.Color('#000000'))
eq_(s.force_odd_labels, False)
eq_(s.halo_fill, mapnik.Color('rgb(255,255,255)'))
eq_(s.halo_radius, 0)
eq_(s.label_placement, mapnik.label_placement.POINT_PLACEMENT)
eq_(s.minimum_distance, 0.0)
eq_(s.text_ratio, 0)
eq_(s.text_size, 6)
eq_(s.wrap_width, 0)
eq_(s.vertical_alignment, mapnik.vertical_alignment.AUTO)
eq_(s.label_spacing, 0)
eq_(s.label_position_tolerance, 0)
# 22.5 * M_PI/180.0 initialized by default
assert_almost_equal(s.max_char_angle_delta, 0.39269908169872414)
eq_(s.wrap_character, ' ')
eq_(s.text_transform, mapnik.text_transform.NONE)
eq_(s.line_spacing, 0)
eq_(s.character_spacing, 0)
# r1341
eq_(s.wrap_before, False)
eq_(s.horizontal_alignment, mapnik.horizontal_alignment.AUTO)
eq_(s.justify_alignment, mapnik.justify_alignment.AUTO)
eq_(s.opacity, 1.0)
# r2300
eq_(s.minimum_padding, 0.0)
# was mixed with s.opacity
eq_(s.text_opacity, 1.0)
eq_(s.shield_displacement, (0.0, 0.0))
# TODO - the pattern in bindings seems to be to get/set
# strings for PathExpressions... should we pass objects?
eq_(s.filename, '../data/images/dummy.png')
# 11c34b1: default transform list is empty, not identity matrix
eq_(s.transform, '')
eq_(s.fontset, None)
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 shield():
symbolizer = mapnik.ShieldSymbolizer(mapnik.Expression('[ref]'), 'DejaVu Sans Book', 8, mapnik.Color('black'),
mapnik.PathExpression(BASE_PATH + '../shields/motorway_shield4.png'))
# symbolizer.filename = file
# symbolizer.allow_overlap = True
# if color is not None:
# symbolizer.fill = color
# if transform is not None:
# symbolizer.transform = transform
symbolizer.min_distance = 300
return symbolizer
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_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_shield_symbolizer_modify():
s = mapnik.ShieldSymbolizer(
mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6,
mapnik.Color('#000000'),
mapnik.PathExpression('../data/images/dummy.png'))
# transform expression
def check_transform(expr, expect_str=None):
s.transform = expr
eq_(s.transform, expr if expect_str is None else expect_str)
check_transform("matrix(1 2 3 4 5 6)", "matrix(1, 2, 3, 4, 5, 6)")
check_transform("matrix(1, 2, 3, 4, 5, 6 +7)",
"matrix(1, 2, 3, 4, 5, (6+7))")
check_transform("rotate([a])")
check_transform("rotate([a] -2)", "rotate(([a]-2))")
check_transform("rotate([a] -2 -3)", "rotate([a], -2, -3)")
check_transform("rotate([a] -2 -3 -4)", "rotate(((([a]-2)-3)-4))")
check_transform("rotate([a] -2, 3, 4)", "rotate(([a]-2), 3, 4)")
check_transform("translate([tx]) rotate([a])")
check_transform("scale([sx], [sy]/2)")
def tileMap(request, version, ezmap_id, zoom, x, y):
try:
if version != "1.0":
raise Http404
try:
ezmap = EzMap.objects.get(id=ezmap_id)
layersMapOptions = LayerMapOptions.objects.filter(
ezmap=ezmap, visible=True).order_by('-position')
except Shapefile.DoesNotExist or Feature.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
if ezmap.changed:
#create de mapnik.map object
ezmap.changed = False
ezmap.save()
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("#ffffff")
#defining the feature layer
for layer in layersMapOptions.all():
label = LayerLabel.objects.get(layerMapOptions=layer)
for layerStyle in layer.styles.all():
shapefile = layer.layer
geometryField = utils.calcGeometryField(
shapefile.geom_type)
query = '(select ' + geometryField + ', attribute_value->\'' + label.field.name + '\' 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,
## use_spatial_index=False)
datasource = mapnik.PostGIS(
user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table=query,
srid=3857,
geometry_field=geometryField,
geometry_table='"shapefile_feature"')
featureLayer = mapnik.Layer(
str(shapefile.filename) + str(layerStyle.id))
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(
str(shapefile.filename) + '_Style' +
str(layerStyle.id))
#defining the feature layer styles
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
s = mapnik.PointSymbolizer(
mapnik.PathExpression(str(layerStyle.iconName)))
s.allow_overlap = True
rule.symbols.append(s)
elif shapefile.geom_type in [
"LineString", "MultiLineString"
]:
rule.symbols.append(
mapnik.LineSymbolizer(
mapnik.Color(str(layerStyle.strokeColor)),
layerStyle.strokeWeight))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
p = mapnik.PolygonSymbolizer(
mapnik.Color(str((layerStyle.fillColor))))
p.fill_opacity = layerStyle.fillOpacity
rule.symbols.append(p)
rule.symbols.append(
mapnik.LineSymbolizer(
mapnik.Color(str(layerStyle.strokeColor)),
layerStyle.strokeWeight))
label = mapnik.TextSymbolizer(
mapnik.Expression('[label]'), 'DejaVu Sans Book',
label.font_size, mapnik.Color(str(label.font_color)))
label.halo_fill = mapnik.Color(str(label.halo_color))
label.halo_radius = int(label.halo_radius)
label.label_placement = mapnik.label_placement.INTERIOR_PLACEMENT
label.allow_overlap = False
label.avoid_edges = True
rule.symbols.append(label)
style = mapnik.Style()
style.rules.append(rule)
#add new feature to the map
map.append_style(
str(shapefile.filename) + '_Style' +
str(layerStyle.id), style)
map.layers.append(featureLayer)
#saving the map mapnik xml
mapnik.save_map(
map, "c:\\mygeosite\\tilestache\\%s\\%s.xml" %
(str(request.user), str(ezmap.map_name)))
config = {
"cache": {
"name": "test",
"path": "../tilestache/%s" % (request.user),
"umask": "0000",
"dirs": "portable"
},
"layers": {
ezmap.map_name: {
"provider": {
"name":
"mapnik",
"mapfile":
"../tilestache/%s/%s.xml" %
(request.user, ezmap.map_name)
},
"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" % (ezmap.map_name, 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("")
### START Layer 1
###
# style object to hold rules
s = mapnik.Style()
# rule object to hold symbolizers
r = mapnik.Rule()
r2 = mapnik.Rule()
# Lines (outlines of polygons and/or simple lines. Line-Color (RGB) line-thickness
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color('red')) #rgb(5%,5%,5%)
# Point Style. Path to marker.png
point_symbolizer = mapnik.PointSymbolizer(mapnik.PathExpression(point_marker))
# Allow Overlaps and set opacity of marker
point_symbolizer.allow_overlap = True
point_symbolizer.opacity = 0.7
# add the polygon_symbolizer to the rule object
r.symbols.append(polygon_symbolizer)
r2.symbols.append(point_symbolizer)
# now add the rule(s) to the style
s.rules.append(r)
s.rules.append(r2)
# Styles are added to the map
m.append_style('My Style', s)
def school_sheds_results(request=None,
school_id=None,
bbox=None,
width=816,
height=1056,
srid=3857,
format='png'):
'''
Default height and width are 'Letter' ratio
'''
format = format.encode('ascii')
school = School.objects.get(pk=school_id)
point = school.geometry
circle = point.buffer(3400.0)
m = mapnik.Map(int(width), int(height), "+init=epsg:" + str(srid))
mapnik.load_map(m, os.path.dirname(__file__) + "/basemap/basemap.xml")
if bbox is None:
circle.transform(srid)
bbox = mapnik.Box2d(*circle.extent)
m.zoom_to_box(bbox)
#m.background = mapnik.Color('steelblue')
# styles for sheds
s = mapnik.Style()
for name, color in (('0.5', VIOLET), ('1.0', PURPLE), ('1.5', LAVENDER),
('2.0', LIGHTCYAN)):
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = " + name)
c = mapnik.Color(color)
c.a = 80
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("gray"), 1)
poly_symbolizer = mapnik.PolygonSymbolizer(c)
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
# styles for schools
school_colors = SCHOOL_COLORS
for name, color in school_colors:
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = '" + name + "'")
line_symbolizer = mapnik.LineSymbolizer()
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(color))
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression(
"[name] != 'map_title' and [name] != 'map_subtitle' and [name] != 'legend_title' and [name] != 'school'"
)
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 9,
mapnik.Color('black'))
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
#text_symbolizer.label_placement = mapnik.label_placement.VERTEX_PLACEMENT
text_symbolizer.allow_overlap = True
text_symbolizer.displacement = (12, 0)
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 15,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_subtitle'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 12,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Condensed Bold', 11,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_box'")
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("white"))
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("black"), 0.5)
poly_symbolizer.fill_opacity = 0.8
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'school'")
ps = mapnik.PointSymbolizer(
mapnik.PathExpression(
os.path.dirname(__file__) + '/static/img/School.svg'))
ps.transform = 'scale(0.06)'
ps.allow_overlap = True
#shield.label_placement = mapnik.label_placement.POINT_PLACEMENT
r.symbols.append(ps)
s.rules.append(r)
m.append_style("surveys", s)
def p2l(pct_x, pct_y):
loc_x = bbox.minx + (bbox.maxx - bbox.minx) * pct_x / 100.0
loc_y = bbox.miny + (bbox.maxy - bbox.miny) * pct_y / 100.0
return (loc_x, loc_y)
sheds = {
0.5: school.shed_05,
1.0: school.shed_10,
1.5: school.shed_15,
2.0: school.shed_20
}
csv_string = 'wkt,name,label\n'
for key, g in reversed(sorted(sheds.items(), key=lambda a: a[0])):
if g is None:
continue
g.srid = 26986
g.transform(srid)
csv_string += '"%s","%s",""\n' % (g.wkt, str(key))
surveys = Survey.objects.filter(school=school)
for survey in surveys:
survey.location.transform(srid)
children = list(survey.child_set.all())
if len(children) > 0:
for c in children:
name = str(c.to_school)
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
else:
name = "o"
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
#Add School geometry
school.geometry.transform(srid)
csv_string += '"%s","school","%s"\n' % (school.geometry.wkt, school.name)
def box(minx, miny, maxx, maxy):
lmin = Point(p2l(minx, miny))
lmax = Point(p2l(maxx, maxy))
lr = LinearRing((lmin.x, lmin.y), (lmax.x, lmin.y), (lmax.x, lmax.y),
(lmin.x, lmax.y), (lmin.x, lmin.y))
poly = Polygon(lr)
return poly
legend = box(2, 108, 50, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(3.5, 112)
point = Point(*xy)
csv_string += '"%s","%s","School Commute Survey Results"\n' % (point.wkt,
"map_title")
xy = p2l(3.5, 109.5)
point = Point(*xy)
csv_string += '"%s","%s","%s, %s"\n' % (point.wkt, "map_subtitle", school,
school.districtid)
legend_x = 53
legend = box(legend_x, 97, 97.5, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(legend_x + 1.5, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Approx. home locations and travel to school mode"\n' % (
point.wkt, )
walksheds_x = 88
xy = p2l(walksheds_x, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Walksheds"\n' % (point.wkt, )
y = 111.5
for name, label in school_colors:
y -= 1.8
xy = p2l(legend_x + 2, y)
point = Point(*xy)
circle = point.buffer(50)
csv_string += '"%s","%s","%s"\n' % (circle.wkt, name, MODE_DICT[name])
y = 110
for name in (
'0.5',
'1.0',
'1.5',
'2.0',
):
y -= 2.4
ws = box(walksheds_x, y, walksheds_x + 2, y + 1.5)
csv_string += '"%s","%s","%s Mile"\n' % (ws.wkt, name, name)
layer = mapnik.Layer('surveys', "+init=epsg:" + str(srid))
ds = mapnik.Datasource(type="csv", inline=csv_string.encode('ascii'))
layer.datasource = ds
layer.styles.append('surveys')
m.layers.append(layer)
# Render to image
if format == 'pdf':
tmp_file = tempfile.NamedTemporaryFile()
surface = cairo.PDFSurface(tmp_file.name, m.width, m.height)
mapnik.render(m, surface)
surface.finish()
tmp_file.seek(0)
im = tmp_file.read()
else:
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
im = im.tostring(format)
response = HttpResponse()
response['Content-length'] = str(len(im))
response['Content-Type'] = mimetypes.types_map['.' + format]
response.write(im)
return response
def xml_map_config(request, zoom, x, y, basqui_map, layersMapOptions):
basqui_map.changed = False
basqui_map.save()
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"
)
for layer in layersMapOptions.all():
try:
layerLabel = LayerLabel.objects.get(layerMapOptions=layer)
except ObjectDoesNotExist:
layerLabel = None
for layerStyle in layer.styles.all():
shapefile = layer.layer
geometryField = utils.calcGeometryField(shapefile.geom_type)
if layerLabel:
query = '(select ' + geometryField + ', attribute_value->\'' + layerLabel.field.name + '\' as label, id_relat from "shapefile_feature" where' + ' shapefile_id in (' + str(
shapefile.id) + ')) as geom'
else:
query = '(select ' + geometryField + ', id_relat from "shapefile_feature" where' + ' shapefile_id in (' + str(
shapefile.id) + ')) as geom'
datasource = mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
port=5433,
table=query,
srid=3857,
geometry_field=geometryField,
geometry_table='"shapefile_feature"')
featureLayer = mapnik.Layer(
str(shapefile.filename) + str(layerStyle.id))
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(
str(shapefile.filename) + '_Style' + str(layerStyle.id))
#defining the feature layer styles
style_rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
s = mapnik.PointSymbolizer(
mapnik.PathExpression(str(layerStyle.iconName)))
s.allow_overlap = True
style_rule.symbols.append(s)
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
style_rule.symbols.append(
mapnik.LineSymbolizer(
mapnik.Color(str(layerStyle.strokeColor)),
layerStyle.strokeWeight))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
p = mapnik.PolygonSymbolizer(
mapnik.Color(str((layerStyle.fillColor))))
p.fill_opacity = layerStyle.fillOpacity
style_rule.symbols.append(p)
style_rule.symbols.append(
mapnik.LineSymbolizer(
mapnik.Color(str(layerStyle.strokeColor)),
layerStyle.strokeWeight))
layer_style = mapnik.Style()
layer_style.rules.append(style_rule)
#defining label styles
if layerLabel:
label_rule = mapnik.Rule()
label = mapnik.TextSymbolizer(
mapnik.Expression('[label]'), 'DejaVu Sans Book',
layerLabel.font_size,
mapnik.Color(str(layerLabel.font_color)))
label.halo_fill = mapnik.Color(str(layerLabel.halo_color))
label.halo_radius = int(layerLabel.halo_radius)
#label.label_placement = mapnik.label_placement.INTERIOR_PLACEMENT
label.allow_overlap = False
label.avoid_edges = True
label_rule.symbols.append(label)
label_style = mapnik.Style()
label_style.rules.append(label_rule)
featureLayer.styles.append(
str(shapefile.filename) + '_label' + str(layerStyle.id))
#add label to the map
map.append_style(
str(shapefile.filename) + '_label' + str(layerStyle.id),
label_style)
#add new feature to the map
map.append_style(
str(shapefile.filename) + '_Style' + str(layerStyle.id),
layer_style)
map.layers.append(featureLayer)
#saving the map mapnik xml
mapnik.save_map(
map, "c:\\basqui\\tilestache\\%s\\%s.xml" %
(str(request.user), str(basqui_map.map_name)))
def pattern(file):
symbolizer = mapnik.PolygonPatternSymbolizer(mapnik.PathExpression(file))
symbolizer.transform = 'scale(0.4, 0.4)'
return symbolizer
from djmapnik.adapter import qs_to_map
import mapnik
# todo - remove <layername>, and remove 'foo' from url in static/treemap.js
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':
# create label symbolizers
if mapnik.mapnik_version() >= 800:
text = mapnik.TextSymbolizer(mapnik.Expression('[Name]'),
'DejaVu Sans Bold', 12, mapnik.Color('black'))
else:
text = mapnik.TextSymbolizer('Name', 'DejaVu Sans Bold', 12,
mapnik.Color('black'))
text.allow_overlap = True
text.displacement(30, -40)
text.halo_radius = 2
text.halo_fill = mapnik.Color(255, 255, 255, 25)
# create point symbolizer for blue icons
if mapnik.mapnik_version() >= 800:
point = mapnik.PointSymbolizer(mapnik.PathExpression('tests/y.png'))
else:
point = mapnik.PointSymbolizer('tests/y.png', 'png', 50, 50)
point.allow_overlap = True
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(point)
r.symbols.append(text)
s.rules.append(r)
lyr = mapnik.Layer('Memory Datasource')
lyr.datasource = pds
lyr.styles.append('Style')
'opacity': 'text_opacity',
'spacing': 'label_spacing',
'max_char_angle_delta': 'maximum_angle_char_delta',
'placement': 'label_placement'
}
total_fails = 0
before = 0
for sym in reference['symbolizers'].items():
if sym[0] not in ['map', '*']:
#if sym[0] in ['raster']:
sym_name = ''.join([s.title() for s in sym[0].split('-')])
sym_object = getattr(mapnik, sym_name + 'Symbolizer')
instance_var = None
if sym_name in ['PolygonPattern', 'LinePattern']:
instance_var = sym_object(mapnik.PathExpression(''))
elif sym_name == 'Shield':
instance_var = sym_object(mapnik.Expression('True'),
'DejaVu Sans Book', 10,
mapnik.Color('black'),
mapnik.PathExpression(''))
else:
instance_var = sym_object()
fails = []
for prop in sym[1]:
key = prop.replace('-', '_')
if key == 'file':
key = 'filename'
if sym_name == 'Line' and 'stroke' in key:
stroke_instance = instance_var.stroke
if key == 'stroke':
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)
# File with symbol for point
file_symbol = os.path.join("figs", "mm_20_white.png")
# Create a map
map = mapnik.Map(800, 400) #This is the image final image size
# Background for the map
map.background = mapnik.Color("steelblue")
# Create the rule and style obj
r = mapnik.Rule()
s = mapnik.Style()
# Set the land polygone
polyStyle = mapnik.PolygonSymbolizer(mapnik.Color("darkred"))
pointStyle = mapnik.PointSymbolizer(mapnik.PathExpression(file_symbol))
r.symbols.append(polyStyle)
r.symbols.append(pointStyle)
s.rules.append(r)
map.append_style("mapStyle", s)
# Adding point layer
layerPoint = mapnik.Layer("pointLayer")
layerPoint.datasource = mapnik.Shapefile(file=os.path.join("data", "map.shp"))
layerPoint.styles.append("mapStyle")
# Adding polygon
layerPoly = mapnik.Layer("polyLayer")
layerPoly.datasource = mapnik.Shapefile(
