def finish_initializing(self, builder): # pylint: disable=E1002
"""Set up the main window"""
super(GeneralcartoWindow, self).finish_initializing(builder)
self.AboutDialog = AboutGeneralcartoDialog
self.PreferencesDialog = PreferencesGeneralcartoDialog
####
#initialize some global variables
self.checkbutton_open = False
self.shapefile = ''
# Get a reference to the builder and set up the signals.
self.builder = builder
self.ui = builder.get_ui(self)
#initialize the entry for the zoomlevels for the tile rendering
self.ui.entry1.set_text('0')
self.ui.entry2.set_text('18')
print 'Mapnik_version = %s' %mapnik.mapnik_version()
if mapnik.mapnik_version() < 200100:
print "You're having a too old version of mapnik...install minimum version 2.1.0!!!"
sys.exit()
#initialize the size of the tile buffer
self.buffer_size = 128
self.ui.entry_buffer.set_text(str(self.buffer_size))
home = os.getenv("HOME")
self.generalHome = home + '/GeneralCarto/'
if not os.path.isdir(self.generalHome):
os.mkdir(self.generalHome)
self.logs = self.generalHome + 'log-files/'
if not os.path.isdir(self.logs):
os.mkdir(self.logs)
self.tile_dir = self.generalHome + 'tiles/'
if not os.path.isdir(self.tile_dir):
os.mkdir(self.tile_dir)
self.previewImage = self.generalHome + "user_image.png"
self.path = ""
self.xml_files_folder = self.generalHome + 'xmlfiles/'
if not os.path.isdir(self.xml_files_folder):
os.mkdir(self.xml_files_folder)
self.menuItemIndicator = "< "
self.textEditor = 'gedit'
#self.loadWindows()
self.tileButtonVisibility(False)
self.initializedMapfile = False
self.initialLoad = True
def GetFeatureInfo(self, params, querymethodname='query_point'):
m = self._buildMap(params)
if params['info_format'] == 'text/plain':
writer = TextFeatureInfo()
elif params['info_format'] == 'text/xml':
writer = XMLFeatureInfo()
if params['query_layers'] and params['query_layers'][0] == '__all__':
for layerindex, layer in enumerate(m.layers):
featureset = getattr(m,
querymethodname)(layerindex, params['i'],
params['j'])
features = featureset.features
if features:
writer.addlayer(layer.name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop, value in feat.attributes.iteritems():
writer.addattribute(prop, value)
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
for layerindex, layername in enumerate(params['query_layers']):
if layername in params['layers']:
# TODO - pretty sure this is bogus, we can't pull from m.layers by the layerindex of the
# 'query_layers' subset, need to pull from:
# self.mapfactory.layers[layername]
if m.layers[layerindex].queryable:
featureset = getattr(m, querymethodname)(layerindex,
params['i'],
params['j'])
features = featureset.features
if features:
writer.addlayer(m.layers[layerindex].name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop, value in feat.attributes.iteritems(
):
writer.addattribute(prop, value)
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
raise OGCException(
'Requested query layer "%s" is not marked queryable.'
% layername, 'LayerNotQueryable')
else:
raise OGCException(
'Requested query layer "%s" not in the LAYERS parameter.'
% layername)
return Response(params['info_format'], str(writer))
def getTextStyle(fieldname):
style = mapnik.Style() # style object to hold rules
rule = mapnik.Rule() # rule object to hold symbolizers
# print(help(mapnik.TextSymbolizer))
print(mapnik.mapnik_version())
symbolizer = mapnik.TextSymbolizer(
mapnik.Expression('[' + fieldname + ']'), 'DejaVu Sans Book', 10,
mapnik.Color('black'))
# symbolizer = mapnik.TextSymbolizer()
# print(symbolizer, dir(symbolizer))
# print(symbolizer.properties.format_tree.text)
# symbolizer.face_name = mapnik.FormattingText('DejaVu Sans Book')
# symbolizer.face_name = 'DejaVu Sans Book'
# symbolizer.properties.format_tree = mapnik.FormattingText('DejaVu Sans Book')
# symbolizer.name = mapnik.Expression('['+fieldname+']')
symbolizer.halo_fill = mapnik.Color('white')
symbolizer.halo_radius = 1
symbolizer.label_placement = label_placement.LINE_PLACEMENT # POINT_PLACEMENT is default
symbolizer.allow_overlap = False
symbolizer.avoid_edges = True
rule.symbols.append(symbolizer)
style.rules.append(rule)
return style
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def render(self, stylefile, bbox, output, width, height):
"""
Render the specified bbox (minx, miny, maxx, maxy) with Mapnik
"""
if not self._mapnik:
self._mapnik = mapnik.Map(width, height)
# Load style XML
mapnik.load_map(self._mapnik, stylefile, True)
# Obtain <Map> projection
self._prj = mapnik.Projection(self._mapnik.srs)
# Convert to map projection
assert len(bbox) == 4, "Provide a bounding box tuple (minx, miny, maxx, maxy)"
c0 = self._prj.forward(mapnik.Coord(bbox[0],bbox[1]))
c1 = self._prj.forward(mapnik.Coord(bbox[2],bbox[3]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
self._mapnik.resize(width, height)
self._mapnik.zoom_to_box(bbox)
self._mapnik.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(width, height)
mapnik.render(self._mapnik, im)
im.save(output, 'png256')
def __init__(self, url, logging, config=''):
self.url = url
self.home_html = None
self.logging = logging
self.proto_schema = {
"xml": {
"test": self.is_xml,
"get": self.get_mapnik,
"request": self.request_mapnik,
"metadata": self.get_metadata,
"enable": True,
},
}
# Load OGCServver config
self.ogcserver = importlib.import_module('ogcserver')
if os.path.isfile(config):
self.ogc_configfile = config
else:
self.ogc_configfile = resource_filename(
self.ogcserver.__name__, 'default.conf'
)
ogcconf = SafeConfigParser()
ogcconf.readfp(open(self.ogc_configfile))
self.ogcconf = ogcconf
if ogcconf.has_option('server', 'debug'):
self.debug = int(ogcconf.get('server', 'debug'))
else:
self.debug = 0
self.mapnik_ver = mapnik_version()
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def render_tile(self, x, y, z, utf_grid):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
if(self.m.buffer_size < 128):
self.m.buffer_size = 128
if utf_grid is True:
grid = mapnik.Grid(self.m.width,self.m.height)
mapnik.render_layer(self.m, grid, layer=0, fields=['html_exp'])
utfgrid = grid.encode('utf', resolution=4)
return json.dumps(utfgrid);
else:
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
return im.tostring('png');
def render_tile(self, tile_uri, x, y, z, buffer_size):
tile = (x,y)
c0, c1 = self.calcTileCoordinates(tile, z)
tile_extent = (c0.x,c0.y, c1.x,c1.y)
#dest_file = "WebGen_WPS_file.xml"
#folder = "/home/klammer/Software/Quickly/tilegen/data/media/"
#test = makeWPSfile(tile_extent, folder+dest_file)
#if test > 0:
# sendFile(dest_file, folder)
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = buffer_size
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def renderPage(ll,file):
z = 2
#imgx = 987 * z
#imgy = 801 * z
imgx = int(987 * z )
imgy = int(987 * z *0.77 )
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
prj = mapnik.Projection("+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over")
c0 = prj.forward(mapnik.Coord(ll[0],ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2],ll[3]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y,c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y,c1.x,c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
view = im.view(0,0,imgx,imgy) # x,y,width,height
map_uri=file + '.png'
view.save(map_uri,'png')
file=open(file+'.svg' ,'w')
surface=cairo.SVGSurface(file.name,imgx,imgy)
mapnik.render(m,surface)
#c = cairo.Context(surface)
#c.move_to(50,50)
#c.show_text('testing')
surface.finish();
def serialize(xml, options):
try:
import mapnik
except:
sys.exit(
color_text(
1,
'Error: saving xml requires Mapnik python bindings to be installed'
))
m = mapnik.Map(1, 1)
if options.from_string:
mapnik.load_map_from_string(m, xml, True)
else:
mapnik.load_map(m, xml, True)
if options.output:
mapnik.save_map(m, options.output)
else:
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 700:
print mapnik.save_map_to_string(m)
else:
sys.exit(
color_text(
1,
'Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file'
))
def fews_point_style(jdbc_source, filterkey, locationkey, parameterkey,
nodata=False, styles=None, lookup=None):
"""
Make mapnik point_style for fews point with given filterkey.
Copied from lizard_fewsunblobbed.
"""
point_style_name, output_filename = fews_symbol_name(
jdbc_source, filterkey, locationkey, parameterkey,
nodata, styles, lookup)
output_filename_abs = os.path.join(
settings.MEDIA_ROOT, 'generated_icons', output_filename)
# use filename in mapnik pointsymbolizer
if mapnik.mapnik_version() < 800:
point_looks = mapnik.PointSymbolizer(
str(output_filename_abs), 'png', 16, 16)
else:
point_looks = mapnik.PointSymbolizer(
mapnik.PathExpression(str(output_filename_abs)))
point_looks.allow_overlap = True
layout_rule = mapnik.Rule()
layout_rule.symbols.append(point_looks)
# We use 'class' to filter the correct style for the locations
layout_rule.filter = mapnik.Filter(
"[style] = '%s'" % str(point_style_name))
point_style = mapnik.Style()
point_style.rules.append(layout_rule)
return point_style_name, point_style
def run(self):
while True:
if not self.queue.empty():
# get point from queue
point = self.queue.get() # point is a tuple
# print point in gui
self.object_map["work_frame"].text.insert(tk.END, "%i,%i\n" % (point[0], point[1]))
self.object_map["work_frame"].text.yview(tk.END)
# make point
pds = mapnik.PointDatasource()
pds.add_point(point[0], point[1], "Name", "d")
# create point symbolizer for blue icons
if mapnik.mapnik_version() >= 800:
point = mapnik.PointSymbolizer(mapnik.PathExpression("y2.png"))
else:
point = mapnik.PointSymbolizer("y2.png", "png", 25, 25)
point.allow_overlap = True
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(point)
s.rules.append(r)
self.layer2 = mapnik.Layer("GPS Coord")
self.layer2.datasource = pds
self.layer2.styles.append("Style")
self.map.append_style("Style", s)
self.map.layers.append(self.layer2)
self.draw()
def check_mapnik_config():
try:
import mapnik
print('{} mapnik {} installed'.format(plus, mapnik.mapnik_version()))
except ImportError:
print('{} install mapnik'.format(minus))
sys.exit(-1)
def render_tile(self, tile_uri, x, y, z, buffer_size):
tile = (x, y)
c0, c1 = self.calcTileCoordinates(tile, z)
tile_extent = (c0.x, c0.y, c1.x, c1.y)
#dest_file = "WebGen_WPS_file.xml"
#folder = "/home/klammer/Software/Quickly/TileGen/tilegen/data/media/"
#test = makeWPSfile(tile_extent, folder+dest_file)
#if test > 0:
# sendFile(dest_file, folder)
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = buffer_size
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def GetFeatureInfo(self, params, querymethodname='query_point'):
m = self._buildMap(params)
if params['info_format'] == 'text/plain':
writer = TextFeatureInfo()
elif params['info_format'] == 'text/xml':
writer = XMLFeatureInfo()
if params['query_layers'] and params['query_layers'][0] == '__all__':
for layerindex, layer in enumerate(m.layers):
featureset = getattr(m, querymethodname)(layerindex, params['i'], params['j'])
features = featureset.features
if features:
writer.addlayer(layer.name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop,value in feat.attributes.iteritems():
writer.addattribute(prop, value)
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
for layerindex, layername in enumerate(params['query_layers']):
if layername in params['layers']:
# TODO - pretty sure this is bogus, we can't pull from m.layers by the layerindex of the
# 'query_layers' subset, need to pull from:
# self.mapfactory.layers[layername]
if m.layers[layerindex].queryable:
featureset = getattr(m, querymethodname)(layerindex, params['i'], params['j'])
features = featureset.features
if features:
writer.addlayer(m.layers[layerindex].name)
for feat in features:
writer.addfeature()
if mapnik_version() >= 800:
for prop,value in feat.attributes.iteritems():
writer.addattribute(prop, value)
else:
for prop in feat.properties:
writer.addattribute(prop[0], prop[1])
else:
raise OGCException('Requested query layer "%s" is not marked queryable.' % layername, 'LayerNotQueryable')
else:
raise OGCException('Requested query layer "%s" not in the LAYERS parameter.' % layername)
return Response(params['info_format'], str(writer))
def GetMap(self, params):
m = self._buildMap(params)
im = Image(params['width'], params['height'])
render(m, im)
format = PIL_TYPE_MAPPING[params['format']]
if mapnik_version() >= 200300:
# Mapnik 2.3 uses png8 as default, use png32 for backwards compatibility
if format == 'png':
format = 'png32'
return Response(params['format'].replace('8',''), im.tostring(format))
def GetMap(self, params):
m = self._buildMap(params)
im = Image(params['width'], params['height'])
render(m, im)
format = PIL_TYPE_MAPPING[params['format']]
if mapnik_version() >= 200300:
# Mapnik 2.3 uses png8 as default, use png32 for backwards compatibility
if format == 'png':
format = 'png32'
return Response(params['format'].replace('8', ''), im.tostring(format))
def local_render_wrapper(self, *args):
"""
Abstraction wrapper for calling for map images rendered with either AGG or Cairo.
"""
if args[2] in self.CAIRO_FILE_FORMATS and hasattr(
mapnik, 'mapnik_version') and mapnik.mapnik_version() < 700:
self.render_with_pycairo(*args)
# todo: support rendering to image formats with cairo
#elif args[2] in self.CAIRO_IMAGE_FORMATS:
#self.render_with_pycairo(*args)
else:
self.render_to_file(*args)
def serialize(xml,options):
try:
import mapnik
except:
sys.exit(color_text(1,'Error: saving xml requires Mapnik python bindings to be installed'))
m = mapnik.Map(1,1)
if options.from_string:
mapnik.load_map_from_string(m,xml,True)
else:
mapnik.load_map(m,xml,True)
if options.output:
mapnik.save_map(m,options.output)
else:
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 700:
print mapnik.save_map_to_string(m)
else:
sys.exit(color_text(1,'Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file'))
def get_bbox(self, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * self.render_size, (y + 1) * self.render_size)
p1 = ((x + 1) * self.render_size, y * self.render_size)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
return mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
return mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
def get_bbox(self): # Calculate pixel positions of bottom-left & top-right p0 = (self.mtx0 * TILE_SIZE, (self.mty0 + self.metatile) * TILE_SIZE) p1 = ((self.mtx0 + self.metatile) * TILE_SIZE, self.mty0 * TILE_SIZE) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, self.zoom); l1 = self.tileproj.fromPixelToLL(p1, self.zoom); # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1])) # Bounding box for the tile if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y) else: bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y) return bbox
def get_bbox(self, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * self.render_size, (y + 1) * self.render_size)
p1 = ((x + 1) * self.render_size, y * self.render_size)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
return mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
return mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
def get_bbox(self): # Calculate pixel positions of bottom-left & top-right p0 = (self.mtx0 * TILE_SIZE, (self.mty0 + self.metatile) * TILE_SIZE) p1 = ((self.mtx0 + self.metatile) * TILE_SIZE, self.mty0 * TILE_SIZE) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, self.zoom); l1 = self.tileproj.fromPixelToLL(p1, self.zoom); # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1])) # Bounding box for the tile if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y) else: bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y) return bbox
def render_image(self, extent, img_size, settings):
# Выбираем объекты по экстенту
feature_query = self.layer.feature_query()
feature_query.intersects(box(*extent, srid=self.layer.srs_id))
feature_query.geom()
features = feature_query()
ds = mapnik.MemoryDatasource()
for (id, f) in enumerate(features):
if mapnik.mapnik_version() < 200100:
feature = mapnik.Feature(id)
else:
feature = mapnik.Feature(mapnik.Context(), id)
feature.add_geometries_from_wkb(f.geom.wkb)
ds.add_feature(feature)
style_content = str(self.style_content)
m = mapnik.Map(img_size[0], img_size[1])
mapnik.load_map_from_string(m, style_content)
m.zoom_to_box(mapnik.Box2d(*extent))
layer = mapnik.Layer('main')
layer.datasource = ds
root = ET.fromstring(style_content)
styles = [s.attrib.get('name') for s in root.iter('Style')]
for s in styles:
layer.styles.append(s)
m.layers.append(layer)
img = mapnik.Image(img_size[0], img_size[1])
mapnik.render(m, img)
data = img.tostring('png')
# Преобразуем изображение из PNG в объект PIL
buf = StringIO()
buf.write(data)
buf.seek(0)
img = Image.open(buf)
return img
def render_image(self, extent, img_size, settings):
# Выбираем объекты по экстенту
feature_query = self.layer.feature_query()
feature_query.intersects(box(*extent, srid=self.layer.srs_id))
feature_query.geom()
features = feature_query()
ds = mapnik.MemoryDatasource()
for (id, f) in enumerate(features):
if mapnik.mapnik_version() < 200100:
feature = mapnik.Feature(id)
else:
feature = mapnik.Feature(mapnik.Context(), id)
feature.add_geometries_from_wkb(f.geom.wkb)
ds.add_feature(feature)
style_content = str(self.style_content)
m = mapnik.Map(img_size[0], img_size[1])
mapnik.load_map_from_string(m, style_content)
m.zoom_to_box(mapnik.Box2d(*extent))
layer = mapnik.Layer('main')
layer.datasource = ds
root = ET.fromstring(style_content)
styles = [s.attrib.get('name') for s in root.iter('Style')]
for s in styles:
layer.styles.append(s)
m.layers.append(layer)
img = mapnik.Image(img_size[0], img_size[1])
mapnik.render(m, img)
data = img.tostring('png')
# Преобразуем изображение из PNG в объект PIL
buf = StringIO()
buf.write(data)
buf.seek(0)
img = Image.open(buf)
return img
def simpleRendering(image, stylesheet, extent):
mapfile = stylesheet
map_uri = image
imgx = 256
imgy = 256
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
#print 'simple Rendering'
#print m.layers
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(extent[0], extent[2], extent[1], extent[3])
else:
bbox = mapnik.Envelope(extent[0], extent[2], extent[1], extent[3])
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save(map_uri, 'png')
def render_tile(self, w, h):
self.m.resize(w, h)
#self.m.zoom_to_box(self.lyr.envelope())
bb = (self.lyr.envelope().minx,self.lyr.envelope().miny,self.lyr.envelope().maxx,self.lyr.envelope().maxy)
lW = bb[2] - bb[0]
lH = bb[3] - bb[1]
lR = lW/lH
r = w/h
mW = 0
mH = 0
if lR > r:
mH = (lW * h)/(w * lH)
elif r < lR:
mW = (w * lH) / (lW * h)
x1 = bb[0] - 0.5*mW
x2 = bb[2] + 0.5*mW
y1 = bb[1] - 0.5*mH
y2 = bb[3] + 0.5*mH
c0 = self.prj.forward(mapnik.Coord(x1, y1))
c1 = self.prj.forward(mapnik.Coord(x2,y2))
# Bounding box for the tile
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bb = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bb = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
self.m.zoom_to_box(bb)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(w, h)
mapnik.render(self.m, im)
im.save(str(self.png), 'png')
def render_tile(self, tile_dir, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256 * aggregate, (y + 1) * 256 * aggregate)
p1 = ((x + 1) * 256 * aggregate, y * 256 * aggregate)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256 * aggregate
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
for i in range(0, aggregate):
# check if we have directories in place
str_x = "%s" % (x * aggregate + i)
zoom = "%s" % z
if not os.path.isdir(tile_dir + zoom + '/' + str_x):
os.mkdir(tile_dir + zoom + '/' + str_x)
for j in range(0, aggregate):
view = im.view(i * 256, j * 256, 256, 256)
#print(i*256,j*256,(i+1)*256,(j+1)*256)
str_y = "%s" % (y * aggregate + j)
tile_uri = tile_dir + zoom + '/' + str_x + '/' + str_y + '.png'
view.save(tile_uri, 'png256')
def simpleRendering(image, stylesheet, extent):
mapfile = stylesheet
map_uri = image
imgx = 256
imgy = 256
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
#print 'simple Rendering'
#print m.layers
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(extent[0],extent[2],extent[1],extent[3])
else:
bbox = mapnik.Envelope(extent[0],extent[2],extent[1],extent[3])
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
view = im.view(0,0,imgx,imgy) # x,y,width,height
view.save(map_uri,'png')
def render(self, bbox, width=None, height=None):
"""
Render the specified tile with Mapnik
"""
width = width or self.tilesize
height = height or self.tilesize
if not self._mapnik:
if not width:
self.tile_size,
self._mapnik = mapnik.Map(width, height)
# Load style XML
mapnik.load_map(self._mapnik, self.stylefile, True)
# Obtain <Map> projection
self._prj = mapnik.Projection(self._mapnik.srs)
# Convert to map projection
assert len(bbox) == 4, _("Provide a bounding box tuple (minx, miny, maxx, maxy)")
c0 = self._prj.forward(mapnik.Coord(bbox[0], bbox[1]))
c1 = self._prj.forward(mapnik.Coord(bbox[2], bbox[3]))
# Bounding box for the tile
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
self._mapnik.resize(width, height)
self._mapnik.zoom_to_box(bbox)
self._mapnik.buffer_size = 128
# Render image with default Agg renderer
tmpfile = NamedTemporaryFile(delete=False)
im = mapnik.Image(width, height)
mapnik.render(self._mapnik, im)
im.save(tmpfile.name, "png256") # TODO: mapnik output only to file?
tmpfile.close()
content = open(tmpfile.name).read()
os.unlink(tmpfile.name)
return content
def render_tile(self, tile_dir, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256 * aggregate, (y + 1) * 256 * aggregate)
p1 = ((x + 1) * 256 * aggregate, y * 256 * aggregate)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
render_size = 256 * aggregate
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
self.m.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
for i in range(0, aggregate):
# check if we have directories in place
str_x = "%s" % (x * aggregate + i)
zoom = "%s" % z
if not os.path.isdir(tile_dir + zoom + "/" + str_x):
os.mkdir(tile_dir + zoom + "/" + str_x)
for j in range(0, aggregate):
view = im.view(i * 256, j * 256, 256, 256)
# print(i*256,j*256,(i+1)*256,(j+1)*256)
str_y = "%s" % (y * aggregate + j)
tile_uri = tile_dir + zoom + "/" + str_x + "/" + str_y + ".png"
view.save(tile_uri, "png256")
def finish_initializing(self, builder): # pylint: disable=E1002
"""Set up the main window"""
super(TilegenWindow, self).finish_initializing(builder)
self.AboutDialog = AboutTilegenDialog
self.PreferencesDialog = PreferencesTilegenDialog
####
# initialize some global variables
self.checkbutton_open = False
self.shapefile = ""
# Get a reference to the builder and set up the signals.
self.builder = builder
self.ui = builder.get_ui(self)
# initialize all params
self.params = preferences.FilesNLogs()
# initialize all definitions
self.definitions = preferences.Definitions()
self.menuItemIndicator = self.definitions.getIndicator()
# set the min- & maxzoom and buffer
self.defineTilingParams()
self.project = preferences.ProjectFile()
# check the installed mapnik version
if mapnik.mapnik_version() < self.definitions.getMinMapnikVersion()[0]:
print self.definitions.getMinMapnikVersion()[1]
self.params.writeToLog(self.definitions.getMinMapnikVersion()[1])
sys.exit()
self.setProjectTitle()
self.ui.label_title.set_alignment(0, 0)
self.tileButtonVisibility(False)
self.initializedMapfile = False
self.initialLoad = True
self.reloaded = False
def finish_initializing(self, builder): # pylint: disable=E1002
"""Set up the main window"""
super(TilegenWindow, self).finish_initializing(builder)
self.AboutDialog = AboutTilegenDialog
self.PreferencesDialog = PreferencesTilegenDialog
####
#initialize some global variables
self.checkbutton_open = False
self.shapefile = ''
# Get a reference to the builder and set up the signals.
self.builder = builder
self.ui = builder.get_ui(self)
#initialize all params
self.params = preferences.FilesNLogs()
#initialize all definitions
self.definitions = preferences.Definitions()
self.menuItemIndicator = self.definitions.getIndicator()
#set the min- & maxzoom and buffer
self.defineTilingParams()
self.project = preferences.ProjectFile()
#check the installed mapnik version
if mapnik.mapnik_version() < self.definitions.getMinMapnikVersion()[0]:
print self.definitions.getMinMapnikVersion()[1]
self.params.writeToLog(self.definitions.getMinMapnikVersion()[1])
sys.exit()
self.setProjectTitle()
self.ui.label_title.set_alignment(0, 0)
self.tileButtonVisibility(False)
self.initializedMapfile = False
self.initialLoad = True
self.reloaded = False
def render(self, bbox, width=None, height=None):
"""
Render the specified tile with Mapnik
"""
width = width or self.tilesize
height = height or self.tilesize
if not self._mapnik:
self._mapnik = mapnik.Map(width, height)
# Load style XML
mapnik.load_map(self._mapnik, self.stylefile, True)
# Obtain <Map> projection
self._prj = mapnik.Projection(self._mapnik.srs)
# Convert to map projection
assert len(bbox) == 4, _(
"Provide a bounding box tuple (minx, miny, maxx, maxy)")
c0 = self._prj.forward(mapnik.Coord(bbox[0], bbox[1]))
c1 = self._prj.forward(mapnik.Coord(bbox[2], bbox[3]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
self._mapnik.resize(width, height)
self._mapnik.zoom_to_box(bbox)
self._mapnik.buffer_size = 128
# Render image with default Agg renderer
tmpfile = NamedTemporaryFile(delete=False)
im = mapnik.Image(width, height)
mapnik.render(self._mapnik, im)
im.save(tmpfile.name, 'png256') # TODO: mapnik output only to file?
tmpfile.close()
content = open(tmpfile.name).read()
os.unlink(tmpfile.name)
return content
def render_tile(self, tile_uri, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * 256, (y + 1) * 256)
p1 = ((x + 1) * 256, y * 256)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z);
l1 = self.tileproj.fromPixelToLL(p1, z);
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
render_size = 256
self.m.resize(render_size, render_size)
self.m.zoom_to_box(bbox)
if(self.m.buffer_size < 128):
self.m.buffer_size = 128
if utf_grid == "true":
grid = mapnik.Grid(self.m.width,self.m.height)
mapnik.render_layer(self.m, grid, layer=0, fields=['html_exp'])
tilefilename = tile_uri[:-4] + '.json'
utfgrid = grid.encode('utf', resolution=4)
with open(tilefilename, 'w') as file:
file.write(json.dumps(utfgrid))
else:
# Render image with default Agg renderer
im = mapnik.Image(render_size, render_size)
mapnik.render(self.m, im)
im.save(tile_uri, 'png256')
def render(self, stylefile, bbox, output, width, height):
"""
Render the specified bbox (minx, miny, maxx, maxy) with Mapnik
"""
if not self._mapnik:
# Register font paths
for family in ['ubuntu-font-family', 'msttcorefonts']:
mapnik.register_fonts(os.path.join(TRUETYPE_FONTS_PATH, family))
mapnik.register_fonts(os.path.join(os.path.expanduser('~'), '.fonts'))
logger.debug(_("Mapnik supported fonts are %s") % [f for f in mapnik.FontEngine.face_names()])
# Instantiate context
self._mapnik = mapnik.Map(width, height)
# Load style XML
mapnik.load_map(self._mapnik, stylefile, True)
# Obtain <Map> projection
self._prj = mapnik.Projection(self._mapnik.srs)
# Convert to map projection
assert len(bbox) == 4, _("Provide a bounding box tuple (minx, miny, maxx, maxy)")
c0 = self._prj.forward(mapnik.Coord(bbox[0],bbox[1]))
c1 = self._prj.forward(mapnik.Coord(bbox[2],bbox[3]))
# Bounding box for the tile
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
self._mapnik.resize(width, height)
self._mapnik.zoom_to_box(bbox)
self._mapnik.buffer_size = 128
# Render image with default Agg renderer
im = mapnik.Image(width, height)
mapnik.render(self._mapnik, im)
im.save(output, 'png256')
except ImportError:
# can still build documentation
pass
from TileStache.Core import KnownUnknown
from TileStache.Geography import getProjectionByName
try:
from PIL import Image
except ImportError:
# On some systems, PIL.Image is known as Image.
import Image
if 'mapnik' in locals():
_version = hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() or 701
if _version >= 20000:
Box2d = mapnik.Box2d
else:
Box2d = mapnik.Envelope
global_mapnik_lock = allocate_lock()
class ImageProvider:
""" Built-in Mapnik provider. Renders map images from Mapnik XML files.
This provider is identified by the name "mapnik" in the TileStache config.
Arguments:
def toposmInfo():
print "Using mapnik version:", mapnik.mapnik_version()
print "Has Cairo:", mapnik.has_cairo()
print "Fonts:"
for face in mapnik.FontEngine.face_names():
print "\t", face
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "osm.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
ll = (75.6683, 30.8026, 76.0679, 31.9897)
#---------------------------------------------------
z = 10
imgx = 500 * z
imgy = 500 * z
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
prj = mapnik.Projection("+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over")
c0 = prj.forward(mapnik.Coord(ll[0],ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2],ll[3]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y,c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y,c1.x,c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
view = im.view(0,0,imgx,imgy) # x,y,width,height
view.save(map_uri,'png')
###
# center of the image
label_x = xmin + ((xmax - xmin) / 2)
# bottom of the image
label_y = ymin + ((ymax - ymin) / 30)
# create PointDatasource
pds = mapnik.PointDatasource()
# place scale at the bottom-center of the map
pds.add_point(label_x, label_y, 'Name', "Scale: 1:" + str(m.scale_denominator()))
# 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'))
s3 = mapnik.Style()
r3 = mapnik.Rule()
r3.symbols.append(text)
s3.rules.append(r3)
lyr3 = mapnik.Layer('Memory Datasource')
lyr3.datasource = pds
lyr3.styles.append('Style')
m.layers.append(lyr3)
m.append_style('Style',s3)
https://github.com/mapnik/Cascadenik
"""
__version__ = '2.6.6'
from os import mkdir, chmod
from os.path import isdir, realpath, expanduser, dirname, exists
from urlparse import urlparse
# import mapnik
try:
import mapnik
except ImportError:
import mapnik2 as mapnik
# detect mapnik version, or assume 0.7.1 if no function exists.
MAPNIK_VERSION = hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() or 701
# make a nice version-looking string out of it, like "0.7.1".
MAPNIK_VERSION_STR = ('%07d' % MAPNIK_VERSION)
MAPNIK_VERSION_STR = '.'.join(map(str, (int(MAPNIK_VERSION_STR[:2]), int(MAPNIK_VERSION_STR[2:-2]), int(MAPNIK_VERSION_STR[-2:]))))
from . import style
from .parse import stylesheet_declarations
# compile module -> "_compile"
from . import compile as _compile
# compile function -> "compile"
from .compile import compile, Directories
# define Cascadenik default cache directory
def mapnik_is_installed():
try:
import mapnik
return mapnik.mapnik_version() > 0
except ImportError:
return False
HAS_PIL = False
try:
import mapnik
HAS_MAPNIK = True
except ImportError:
HAS_MAPNIK = False
MAPNIK_AUTO_IMAGE_SUPPORT = None
MAPNIK_VERSION = None
# if mapnik is actually installed we attempt
# to benefit from knowing its version
if HAS_MAPNIK:
if hasattr(mapnik, 'mapnik_version'):
MAPNIK_VERSION = mapnik.mapnik_version()
# note, bugs in 0.7.0 require *_pattern_symbolizer image type,width,height to be specified
# this is fixed in 0.8.0, but we may release 701 to fix this problem, hence 701
if MAPNIK_VERSION >= 701:
MAPNIK_AUTO_IMAGE_SUPPORT = True
if not HAS_PIL:
warn = 'Warning: PIL (Python Imaging Library) is required for proper handling of image symbolizers when using JPEG format images or not running Mapnik >=0.7.0\n'
sys.stderr.write(warn)
DEFAULT_ENCODING = 'utf-8'
try:
import xml.etree.ElementTree as ElementTree
from xml.etree.ElementTree import Element
except ImportError:
def generate_big_tile(pixelsize,x1,y1,zoomlevel,osmdraw,tma=False,return_format="PIL",user=None,only_user=False):
"""
set osmdraw==True and make sure a full working openstreetmap mapnik environment is available,
in order to draw using mapnik. If false, a basemap must already have been drawn, and all that can
be done is that new airspaces etc an be filled in.
"""
def only(x):
if only_user:
#print "Ignoring ",len(x)
return []
return x
print "TMA:",tma
imgx,imgy=pixelsize
assert osmdraw in [True,False]
if not osmdraw: #osmdraw should probably be renamed use 'use_existing_basemap'
print "Making %dx%d tile at %s/%s, zoomlevel: %d"%(pixelsize[0],pixelsize[1],x1,y1,zoomlevel)
print "Generating tile"
print "mapnikstyle file:",os.getenv("SWFP_MAPNIK_STYLE")
mapfile = os.path.join(os.getenv("SWFP_MAPNIK_STYLE"),"osm.xml")
#---------------------------------------------------
# Change this to the bounding box you want
#
# lon lat lon lat
#ll = (center[1], hilat, center[1], lolat)
#---------------------------------------------------
lat1,lon1=mapper.merc2latlon((x1,y1),zoomlevel)
lat2,lon2=mapper.merc2latlon((x1+imgx,y1+imgy),zoomlevel)
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
c0 = prj.forward(mapnik.Coord(lon1,lat1))
c1 = prj.forward(mapnik.Coord(lon2,lat2))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
#bbox = mapnik.Box2d(0,0,256<<zoomlevel,256<<zoomlevel)
bbox = mapnik.Box2d(c0.x,c0.y,c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y,c1.x,c1.y)
#bbox = mapnik.Envelope(0,0,256<<zoomlevel,256<<zoomlevel)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
buf=im.tostring()
#print "len im tostring:" ,len(buf)
assert len(buf)%4==0
num_pixels=len(buf)/4
as_array=numpy.fromstring(buf,numpy.dtype("u1"))
assert len(as_array)==len(buf)
r,g,b,a=numpy.hsplit(as_array.reshape(num_pixels,4),(1,2,3))
assert len(r)==num_pixels
print "Num pixels: ",num_pixels
swapped=numpy.column_stack((b,g,r,a)).reshape(4*num_pixels)
assert len(swapped)==num_pixels*4
assert num_pixels==imgx*imgy
im=cairo.ImageSurface.create_for_data(swapped,cairo.FORMAT_RGB24,imgx,imgy)
#as_array=numpy.fromstring(buf,numpy.dtype("u4"))
#as_array.byteswap(True)
else:
#print "Reading existing map instead"
im=Image.new("RGBA",(imgx,imgy))
for i in xrange(0,pixelsize[0],256):
for j in xrange(0,pixelsize[1],256):
rawtile,tilemeta=maptilereader.gettile("plain",zoomlevel,x1+i,y1+j)
io=StringIO.StringIO(rawtile)
io.seek(0)
sub=Image.open(io)
im.paste(sub,(i,j,i+256,j+256))
buf=im.tostring()
#print "len im tostring:" ,len(buf)
assert len(buf)%4==0
num_pixels=len(buf)/4
assert num_pixels==imgx*imgy
as_array=numpy.fromstring(buf,numpy.dtype("u1"))
assert len(as_array)==len(buf)
r,g,b,a=numpy.hsplit(as_array.reshape(num_pixels,4),(1,2,3))
assert len(r)==num_pixels
#print "Num pixels: ",num_pixels
swapped=numpy.column_stack((b,g,r,a)).reshape(4*num_pixels)
im=cairo.ImageSurface.create_for_data(swapped,cairo.FORMAT_RGB24,imgx,imgy)
ctx=cairo.Context(im)
if tma:
def tolocal(merc):
return (merc[0]-x1,merc[1]-y1)
merc13=mapper.merc2merc((x1-50,y1-50),zoomlevel,13)
merc13b=mapper.merc2merc((x1+imgx+50,y1+imgy+50),zoomlevel,13)
bb13=BoundingBox(merc13[0],merc13[1],merc13b[0],merc13b[1])
bycolor=dict()
for space in chain(
only(get_airspaces_in_bb2(bb13)),get_notam_objs_cached()['areas'],
only(get_aip_sup_areas()),get_firs(),userdata.get_all_airspaces(user)):
if space['type']=='sector':
continue #Don't draw "sectors"
vertices=[]
for coord in space['points']:
merc=mapper.latlon2merc(mapper.from_str(coord),zoomlevel)
vertices.append(tolocal(merc))#merc[0]-x1,merc[1]-y1)
try:
areacol,solidcol=get_airspace_color(space['type'])
except Exception:
print space
raise
bycolor.setdefault((areacol,solidcol),[]).append(vertices)
def colorsorter(col):
if col[0]>0.5: return (110,0,0,0)
return col
for (areacol,solidcol),polygons in sorted(bycolor.items(),key=lambda x:colorsorter(x[0])):
if areacol[3]<=0.05: continue
surface2 = cairo.ImageSurface(cairo.FORMAT_ARGB32, imgx, imgy)
ctx2=cairo.Context(surface2)
ctx2.set_operator(cairo.OPERATOR_DEST_OUT)
ctx2.rectangle(0,0,imgx,imgy)
ctx2.set_source(cairo.SolidPattern(0,0,0,1.0))
ctx2.paint()
ctx2.set_operator(cairo.OPERATOR_OVER)
for poly in polygons:
ctx2.new_path()
for vert in poly:
ctx2.line_to(*vert)
ctx2.close_path()
ctx2.set_source(cairo.SolidPattern(areacol[0],areacol[1],areacol[2],1.0))
ctx2.fill_preserve()
ctx2.set_operator(cairo.OPERATOR_DEST_OUT)
ctx2.rectangle(0,0,imgx,imgy)
ctx2.set_source(cairo.SolidPattern(0,0,0,1.0-areacol[3]))
ctx2.paint()
#ctx2.set_operator(cairo.OPERATOR_OVER)
ctx.set_source_surface(surface2)
ctx.rectangle(0,0,imgx,imgy)
ctx.paint()
for (areacol,solidcol),polygons in sorted(bycolor.items(),key=lambda x:colorsorter(x[1])):
for poly in polygons:
ctx.new_path()
for vert in poly:
ctx.line_to(*vert)
ctx.close_path()
ctx.set_source(cairo.SolidPattern(*solidcol))
ctx.stroke()
for obst in chain(only(get_obstacles_in_bb(bb13)),userdata.get_all_obstacles(user)):
if zoomlevel>=9:
ctx.set_source(cairo.SolidPattern(1.0,0.0,1.0,0.25))
merc=mapper.latlon2merc(mapper.from_str(obst['pos']),zoomlevel)
pos=tolocal(merc)#(merc[0]-x1,merc[1]-y1)
radius=parse_obstacles.get_pixel_radius(obst,zoomlevel)
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.fill_preserve()
ctx.set_source(cairo.SolidPattern(1.0,0.0,1.0,0.75))
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.stroke()
for sigp in chain(only(get_sig_points_in_bb(bb13)),userdata.get_all_sigpoints(user)):
if zoomlevel>=9:
#print sigp
if zoomlevel==9 and sigp.get('kind','') in ['entry/exit point','holding point']:
continue
if sigp.get('kind','') in ['town','city']:continue
merc=mapper.latlon2merc(mapper.from_str(sigp['pos']),zoomlevel)
pos=tolocal(merc)#(merc[0]-x1,merc[1]-y1)
ctx.set_source(cairo.SolidPattern(0.0,0.0,1.0,0.65))
ctx.new_path()
ctx.line_to(pos[0],pos[1]-3)
ctx.line_to(pos[0]+3,pos[1])
ctx.line_to(pos[0],pos[1]+3)
ctx.line_to(pos[0]-3,pos[1])
ctx.close_path()
ctx.stroke()
for notamtype,items in get_notam_objs_cached().items():
if notamtype=="areas": continue
for item in items:
if zoomlevel>=8:
ctx.set_source(cairo.SolidPattern(0.25,1,0.25,0.25))
merc=mapper.latlon2merc(mapper.from_str(item['pos']),zoomlevel)
pos=tolocal(merc)#(merc[0]-x1,merc[1]-y1)
radius=5
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.fill_preserve()
ctx.set_source(cairo.SolidPattern(0,1.0,0,0.75))
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.stroke()
for airfield in chain(only(get_airfields_in_bb(bb13)),userdata.get_all_airfields(user)):
if zoomlevel<6:
continue
ctx.set_source(cairo.SolidPattern(0.8,0.5,1.0,0.25))
merc=mapper.latlon2merc(mapper.from_str(airfield['pos']),zoomlevel)
pos=(merc[0]-x1,merc[1]-y1)
if zoomlevel<=11:
radius=5
else:
radius=5<<(zoomlevel-11)
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.fill_preserve()
ctx.set_source(cairo.SolidPattern(0.8,0.5,1.0,0.75))
ctx.new_path()
ctx.arc(pos[0],pos[1],radius,0,2*math.pi)
ctx.stroke()
for rwy in airfield.get('runways',[]):
ends=rwy['ends']
mercs=[]
#print "Ends:",ends
surface=rwy.get('surface','hard').lower()
for end in ends:
#print "pos:",end['pos']
latlon=mapper.from_str(end['pos'])
#print "latlon:",latlon
merc=mapper.latlon2merc(latlon,zoomlevel)
#print "Merc:",merc
mercs.append(merc)
if len(mercs)==2:
a,b=mercs
#print "Drawing:",airfield['icao'],a,b
if surface=='gravel':
ctx.set_source(cairo.SolidPattern(0.5,0.3,0.0,1))
elif surface=='grass':
ctx.set_source(cairo.SolidPattern(0.0,0.65,0.0,1))
else:
ctx.set_source(cairo.SolidPattern(0.0,0.0,0.0,1))
lwidth=mapper.approx_scale(a,zoomlevel,40.0/1852.0)
if lwidth<=2:
lwidth=2.0
ctx.set_line_width(lwidth)
ctx.new_path()
ctx.move_to(*tolocal(a))
ctx.line_to(*tolocal(b))
ctx.stroke()
if return_format=="PIL":
b,g,r,a=numpy.hsplit(swapped.reshape(num_pixels,4),(1,2,3))
back=numpy.column_stack((r,g,b)).reshape(3*num_pixels)
im=Image.frombuffer("RGB",(imgx,imgy),back,'raw','RGB',0,1)
else:
assert return_format=="cairo"
pass
#print "Returning rendered image and map"
return im
'''
outsidePage, new_coord = self.currentpage.add_next_point(
prev_coord, coord)
if outsidePage:
self.pages.append(self.currentpage)
self.renderedareas.append(self.currentpage.renderarea)
self.__add_first_point(new_coord)
self.__add_next_point(new_coord, coord)
return new_coord
# MAIN
if not hasattr(mapnik, 'mapnik_version') or mapnik.mapnik_version() < 600:
raise SystemExit('This script requires Mapnik >= 0.6.0)')
# enable to search other paths for fonts
# mapnik.FontEngine.register_fonts("/usr/share/fonts/noto", True)
# mapnik.FontEngine.register_fonts("/usr/share/fonts/noto-cjk", True)
# mapnik.FontEngine.register_fonts("/usr/share/fonts/TTF", True)
params = Parameters()
if not params.parse_commandline():
sys.exit()
tracks = Tracks(params.gpxfiles)
if params.waypt_distance > 0:
tracks.calculate_waypoints(params.waypt_distance)
def layer(self, layer_ids=None, webcolor=None, request=None):
"""Return layer and styles that render points.
"""
layers = []
styles = {}
layer = mapnik.Layer("FEWS JDBC points layer", coordinates.WGS84)
if mapnik.mapnik_version() < 800:
layer.datasource = mapnik.PointDatasource()
else:
layer.datasource = mapnik.MemoryDatasource()
context = mapnik.Context()
try:
named_locations = self._locations()
except FewsJdbcQueryError:
logger.exception('Problem querying locations from jdbc2ei.')
return [], {}
if isinstance(self.jdbc_source, JdbcSource):
fews_styles, fews_style_lookup = IconStyle._styles_lookup()
else:
fews_styles, fews_style_lookup = IconStyleWebRS._styles_lookup()
logger.debug("Number of point objects: %d" % len(named_locations))
for i, named_location in enumerate(named_locations):
#logger.debug('layer coordinates %s %s %s' % (
# named_location['locationid'],
# named_location['longitude'],
# named_location['latitude']))
point_style_name, point_style = fews_point_style(
self.jdbc_source,
self.filterkey,
named_location['locationid'],
self.parameterkey,
nodata=False,
styles=fews_styles,
lookup=fews_style_lookup)
# Put style in point, filters work on these styles.
if mapnik.mapnik_version() < 800:
add_datasource_point(
layer.datasource, named_location['longitude'],
named_location['latitude'], 'style', str(point_style_name))
else:
add_datasource_point_mapnik2(
layer.datasource, named_location['longitude'],
named_location['latitude'], 'style',
str(point_style_name), _id=i, context=context)
# generate "unique" point style name and append to layer
# if the same style occurs multiple times, it will overwrite old.
style_name = str("Lizard-FewsJdbc::%s" % (point_style_name))
styles[style_name] = point_style
# Add all style names to the layer styles.
for style_name in styles.keys():
layer.styles.append(style_name)
layers = [layer, ]
return layers, styles
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import cairo
import gi
gi.require_version('Rsvg', '2.0')
gi.require_version('Pango', '1.0')
gi.require_version('PangoCairo', '1.0')
from gi.repository import Rsvg, Pango, PangoCairo
import logging
import mapnik
assert mapnik.mapnik_version() >= 300000, \
"Mapnik module version %s is too old, see ocitysmap's INSTALL " \
"for more details." % mapnik.mapnik_version_string()
import math
import os
import re
import shapely.wkt
import sys
from colour import Color
from . import commons
from ocitysmap.maplib.map_canvas import MapCanvas
from ocitysmap.maplib.grid import Grid
from ocitysmap import draw_utils, maplib
from pluginbase import PluginBase
parser.add_option(
'--aspect-fix-mode',
dest='aspect_fix_mode',
type='string',
help=
'Pass an aspect_fix_mode string (case-insensitive match of http://media.mapnik.org/api_docs/python/mapnik._mapnik.aspect_fix_mode-class.html)',
action='store')
if __name__ == '__main__':
(options, args) = parser.parse_args()
import mapnik
if options.scale_factor:
if not mapnik.mapnik_version() >= 800:
parser.error(
'\nPassing a scale factor requires at least mapnik >= 2.0.0\n')
if len(args) == 0:
parser.error(
'\nPlease provide the path to a Mapnik xml or Cascadenik mml file\n'
)
elif len(args) == 1 and not options.dry_run:
parser.error('\nPlease provide an output image name\n')
if args[0] == '-' and not sys.stdin.isatty():
xml = sys.stdin.read()
if hasattr(mapnik, 'load_map_from_string'):
options.from_string = True
def local_render_wrapper(self,*args):
"""
Abstraction wrapper for calling for map images rendered with either AGG or Cairo.
"""
if args[2] in self.CAIRO_FILE_FORMATS and hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() < 700:
self.render_with_pycairo(*args)
# todo: support rendering to image formats with cairo
#elif args[2] in self.CAIRO_IMAGE_FORMATS:
#self.render_with_pycairo(*args)
else:
self.render_to_file(*args)
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "osm.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
ll = (-6.5, 49.5, 2.1, 59)
#---------------------------------------------------
z = 10
imgx = 500 * z
imgy = 1000 * z
m = mapnik.Map(imgx,imgy)
mapnik.load_map(m,mapfile)
prj = mapnik.Projection("+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over")
c0 = prj.forward(mapnik.Coord(ll[0],ll[1]))
c1 = prj.forward(mapnik.Coord(ll[2],ll[3]))
if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(c0.x,c0.y,c1.x,c1.y)
else:
bbox = mapnik.Envelope(c0.x,c0.y,c1.x,c1.y)
m.zoom_to_box(bbox)
im = mapnik.Image(imgx,imgy)
mapnik.render(m, im)
view = im.view(0,0,imgx,imgy) # x,y,width,height
view.save(map_uri,'png')
def _buildMap(self, params):
if str(params['crs']) not in self.allowedepsgcodes:
raise OGCException(
'Unsupported CRS "%s" requested.' % str(params['crs']).upper(),
'InvalidCRS')
if params['bbox'][0] >= params['bbox'][2]:
raise OGCException(
"BBOX values don't make sense. minx is greater than maxx.")
if params['bbox'][1] >= params['bbox'][3]:
raise OGCException(
"BBOX values don't make sense. miny is greater than maxy.")
# relax this for now to allow for a set of specific layers (meta layers even)
# to be used without known their styles or putting the right # of commas...
#if params.has_key('styles') and len(params['styles']) != len(params['layers']):
# raise OGCException('STYLES length does not match LAYERS length.')
m = Map(params['width'], params['height'], '+init=%s' % params['crs'])
transparent = params.get('transparent', '').lower() == 'true'
# disable transparent on incompatible formats
if transparent and params.get('format', '') == 'image/jpeg':
transparent = False
if transparent:
# transparent has highest priority
pass
elif params.has_key('bgcolor'):
# if not transparent use bgcolor in url
m.background = params['bgcolor']
else:
# if not bgcolor in url use map background
if mapnik_version() >= 200000:
bgcolor = self.mapfactory.map_attributes.get('bgcolor', None)
else:
bgcolor = self.mapfactory.map_attributes.get(
'background-color', None)
if bgcolor:
m.background = bgcolor
else:
# if not map background defined use white color
m.background = Color(255, 255, 255, 255)
if params.has_key('buffer_size'):
if params['buffer_size']:
m.buffer_size = params['buffer_size']
else:
buffer_ = self.mapfactory.map_attributes.get('buffer_size')
if buffer_:
m.buffer_size = self.mapfactory.map_attributes['buffer_size']
# haiti spec tmp hack! show meta layers without having
# to request huge string to avoid some client truncating it!
if params['layers'] and params['layers'][0] in (
'osm_haiti_overlay', 'osm_haiti_overlay_900913'):
for layer_obj in self.mapfactory.ordered_layers:
layer = copy_layer(layer_obj)
if not hasattr(layer, 'meta_style'):
pass
else:
layer.styles.append(layer.meta_style)
m.append_style(
layer.meta_style,
self.mapfactory.meta_styles[layer.meta_style])
m.layers.append(layer)
# a non WMS spec way of requesting all layers
# uses orderedlayers that preserves original ordering in XML mapfile
elif params['layers'] and params['layers'][0] == '__all__':
for layer_obj in self.mapfactory.ordered_layers:
# if we don't copy the layer here we get
# duplicate layers added to the map because the
# layer is kept around and the styles "pile up"...
layer = copy_layer(layer_obj)
if hasattr(layer, 'meta_style'):
continue
reqstyle = layer.wmsdefaultstyle
if reqstyle in self.mapfactory.aggregatestyles.keys():
for stylename in self.mapfactory.aggregatestyles[reqstyle]:
layer.styles.append(stylename)
else:
layer.styles.append(reqstyle)
for stylename in layer.styles:
if stylename in self.mapfactory.styles.keys():
m.append_style(stylename,
self.mapfactory.styles[stylename])
m.layers.append(layer)
else:
for layerindex, layername in enumerate(params['layers']):
if layername in self.mapfactory.meta_layers:
layer = copy_layer(self.mapfactory.meta_layers[layername])
layer.styles.append(layername)
m.append_style(layername,
self.mapfactory.meta_styles[layername])
else:
try:
# uses unordered dict of layers
# order based on params['layers'] request which
# should be originally informed by order of GetCaps response
layer = copy_layer(self.mapfactory.layers[layername])
except KeyError:
raise OGCException(
'Layer "%s" not defined.' % layername,
'LayerNotDefined')
try:
reqstyle = params['styles'][layerindex]
except IndexError:
reqstyle = ''
if len(layer.wmsextrastyles) > 1 and reqstyle == 'default':
reqstyle = ''
if reqstyle and reqstyle not in layer.wmsextrastyles:
raise OGCException(
'Invalid style "%s" requested for layer "%s".' %
(reqstyle, layername), 'StyleNotDefined')
if not reqstyle:
reqstyle = layer.wmsdefaultstyle
if reqstyle in self.mapfactory.aggregatestyles.keys():
for stylename in self.mapfactory.aggregatestyles[
reqstyle]:
layer.styles.append(stylename)
else:
layer.styles.append(reqstyle)
for stylename in layer.styles:
if stylename in self.mapfactory.styles.keys():
m.append_style(stylename,
self.mapfactory.styles[stylename])
else:
raise ServerConfigurationError(
'Layer "%s" refers to non-existent style "%s".'
% (layername, stylename))
m.layers.append(layer)
m.zoom_to_box(
Envelope(params['bbox'][0], params['bbox'][1], params['bbox'][2],
params['bbox'][3]))
return m
from TileStache.Geography import getProjectionByName
try:
from PIL import Image
except ImportError:
# On some systems, PIL.Image is known as Image.
import Image
try:
import mapnik
except ImportError:
# mapnik 2.0.0 is known as mapnik2
import mapnik2 as mapnik
if 'mapnik' in locals():
_version = hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() or 701
if _version >= 20000:
Box2d = mapnik.Box2d
else:
Box2d = mapnik.Envelope
global_mapnik_lock = allocate_lock()
class ImageProvider:
""" Built-in Mapnik provider. Renders map images from Mapnik XML files.
This provider is identified by the name "mapnik" in the TileStache config.
Arguments:
# This is to generate an OSM Water Reference Image # This is based on Mapnik code # This code has been seriously hacked by Pat Cappealere [email protected] # import mapnik import sys, os import argparse merc = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" latlon = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs" # ensure minimum mapnik version if not hasattr(mapnik, 'mapnik_version') and not mapnik.mapnik_version() >= 600: raise SystemExit('This script requires Mapnik >=0.6.0)') # ======================================================================== # generate_image.py --mapfile water.xml --bbox -72.7738 18.0985 -72.1611 18.7072 --name water_image.png # generate_image.py --mapfile osm.xml --bbox -72.7738 18.0985 -72.1611 18.7072 --name osm_image.png # generate_image.py --mapfile water.xml --bbox -75.0 17.0 -70.0 20.0 --name n15w075_water_image.png # generate_image.py --mapfile water.xml --bbox -74.9995833 16.999583 -69.9995833 19.999583 --name n15w075_water_image.tif # generate_image.py --mapfile water.xml --bbox -72.5 18.0 -71.5 19.0 --name port_au_prince_water_image.png # change black to transparent # convert -transparent black image.png osm_water.png if __name__ == "__main__": try: mapfile = os.environ['MAPNIK_MAP_FILE'] except KeyError:
https://github.com/mapnik/Cascadenik
"""
__version__ = '2.4.3'
from os import mkdir, chmod
from os.path import isdir, realpath, expanduser, dirname, exists
from urlparse import urlparse
# import mapnik
try:
import mapnik
except ImportError:
import mapnik2 as mapnik
# detect mapnik version, or assume 0.7.1 if no function exists.
MAPNIK_VERSION = hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() or 701
# make a nice version-looking string out of it, like "0.7.1".
MAPNIK_VERSION_STR = ('%07d' % MAPNIK_VERSION)
MAPNIK_VERSION_STR = '.'.join(map(str, (int(MAPNIK_VERSION_STR[:2]), int(MAPNIK_VERSION_STR[2:-2]), int(MAPNIK_VERSION_STR[-2:]))))
from . import style
from .parse import stylesheet_declarations
# compile module -> "_compile"
from . import compile as _compile
# compile function -> "compile"
from .compile import compile, Directories
# define Cascadenik default cache directory
except:
import mapnik
import sys, os
# Set up projections
# spherical mercator (most common target map projection of osm data imported with osm2pgsql)
merc = mapnik.Projection('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over')
# long/lat in degrees, aka ESPG:4326 and "WGS 84"
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# can also be constructed as:
#longlat = mapnik.Projection('+init=epsg:4326')
# ensure minimum mapnik version
if not hasattr(mapnik,'mapnik_version') and not mapnik.mapnik_version() >= 600:
raise SystemExit('This script requires Mapnik >=0.6.0)')
if __name__ == "__main__":
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = "mapquest-us.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
bounds = (-96, 33, -89, 36)
#bounds = (-92.1213, 34.4818, -91.6327, 35.0762) #close up example showing roads
import os
import logging
import json
import mapnik
from TileStache.Core import KnownUnknown
from TileStache.Geography import getProjectionByName
try:
from PIL import Image
except ImportError:
# On some systems, PIL.Image is known as Image.
import Image
if 'mapnik' in locals():
_version = hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() or 701
if _version >= 20000:
Box2d = mapnik.Box2d
else:
Box2d = mapnik.Envelope
global_mapnik_lock = allocate_lock()
class ImageProvider:
""" Built-in Mapnik provider. Renders map images from Mapnik XML files.
This provider is identified by the name "mapnik" in the TileStache config.
Arguments:
type='float',
help='Pass a scale factor to the Mapnik renderer (experimental)',
action='store')
parser.add_option('--aspect-fix-mode', dest='aspect_fix_mode',
type='string',
help='Pass an aspect_fix_mode string (case-insensitive match of http://media.mapnik.org/api_docs/python/mapnik._mapnik.aspect_fix_mode-class.html)',
action='store')
if __name__ == '__main__':
(options, args) = parser.parse_args()
import mapnik
if options.scale_factor:
if not mapnik.mapnik_version() >= 800:
parser.error('\nPassing a scale factor requires at least mapnik >= 2.0.0\n')
if len(args) == 0:
parser.error('\nPlease provide the path to a Mapnik xml or Cascadenik mml file\n')
elif len(args) == 1 and not options.dry_run:
parser.error('\nPlease provide an output image name\n')
if args[0] == '-' and not sys.stdin.isatty():
xml = sys.stdin.read()
if hasattr(mapnik,'load_map_from_string'):
options.from_string = True
mapfile = xml
else:
options.from_string = False
from ohdm_django_mapnik.ohdm.utily import get_style_xml
ROOT_DIR = (
environ.Path(__file__) - 3
) # (ohdm_django_mapnik/config/settings/base.py - 3 = ohdm_django_mapnik/)
APPS_DIR = ROOT_DIR.path("ohdm_django_mapnik")
env = environ.Env()
READ_DOT_ENV_FILE = env.bool("DJANGO_READ_DOT_ENV_FILE", default=False)
if READ_DOT_ENV_FILE:
# OS environment variables take precedence over variables from .env
env.read_env(str(ROOT_DIR.path(".env")))
# print mapnik version
print("Mapnik version: {}".format(mapnik.mapnik_version()))
# GENERAL
# ------------------------------------------------------------------------------
# https://docs.djangoproject.com/en/dev/ref/settings/#debug
DEBUG = env.bool("DJANGO_DEBUG", False)
# Local time zone. Choices are
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# though not all of them may be available with every OS.
# In Windows, this must be set to your system time zone.
TIME_ZONE = "Europe/Berlin"
# https://docs.djangoproject.com/en/dev/ref/settings/#language-code
LANGUAGE_CODE = "en-us"
# https://docs.djangoproject.com/en/dev/ref/settings/#site-id
SITE_ID = 1
# https://docs.djangoproject.com/en/dev/ref/settings/#use-i18n
