def __init__(self, configpath, mapfile=None,fonts=None,home_html=None):
conf = SafeConfigParser()
conf.readfp(open(configpath))
# TODO - be able to supply in config as well
self.home_html = home_html
self.conf = conf
if fonts:
mapnik.register_fonts(fonts)
if mapfile:
wms_factory = BaseWMSFactory(configpath)
# TODO - add support for Cascadenik MML
wms_factory.loadXML(mapfile)
wms_factory.finalize()
self.mapfactory = wms_factory
else:
if not conf.has_option_with_value('server', 'module'):
raise ServerConfigurationError('The factory module is not defined in the configuration file.')
try:
mapfactorymodule = do_import(conf.get('server', 'module'))
except ImportError:
raise ServerConfigurationError('The factory module could not be loaded.')
if hasattr(mapfactorymodule, 'WMSFactory'):
self.mapfactory = getattr(mapfactorymodule, 'WMSFactory')()
else:
raise ServerConfigurationError('The factory module does not have a WMSFactory class.')
if conf.has_option('server', 'debug'):
self.debug = int(conf.get('server', 'debug'))
else:
self.debug = 0
if self.conf.has_option_with_value('server', 'maxage'):
self.max_age = 'max-age=%d' % self.conf.get('server', 'maxage')
else:
self.max_age = None
def __init__(self,
configpath,
fonts=None,
home_html=None,
**kwargs
):
conf = SafeConfigParser()
conf.readfp(open(configpath))
# TODO - be able to supply in config as well
self.home_html = home_html
self.conf = conf
if fonts:
mapnik.register_fonts(fonts)
if 'debug' in kwargs:
self.debug = bool(kwargs['debug'])
else:
self.debug = False
if self.debug:
self.debug=1
else:
self.debug=0
if 'maxage' in kwargs:
self.max_age = 'max-age=%d' % kwargs.get('maxage')
else:
self.max_age = None
def __init__(self):
"""
Perform argument processing and other setup for a InvarUtility.
"""
self._init_common_parser()
self.add_arguments()
self.args = self.argparser.parse_args()
self._install_exception_handler()
if hasattr(self.args, 'font_paths'):
for font_path in self.args.font_paths:
mapnik.register_fonts(font_path)
def __init__(self):
"""
Perform argument processing and other setup for a InvarUtility.
"""
self._init_common_parser()
self.add_arguments()
self.args = self.argparser.parse_args()
self._install_exception_handler()
if hasattr(self.args, 'font_paths'):
for font_path in self.args.font_paths:
mapnik.register_fonts(font_path)
def setUp(self):
# The sample_world theme uses Dejavu font family which is either
# distrubuted by mapnik or fonts-dejavu-core package.
if sys.platform == 'darwin':
mapnik.register_fonts('/Library/Fonts/')
elif sys.platform == 'linux2':
mapnik.register_fonts('/usr/share/fonts')
theme_root = os.path.join(SAMPLE_THEME_DIRECTORY, 'sample_world')
self.style_sheet = os.path.join(theme_root, 'sample_world.xml')
self.map = mapnik.Map(512, 512) # zoom > 1 so admin0 label got rendered
mapnik.load_map(self.map, self.style_sheet)
def __init__(self, configpath, mapfile=None, fonts=None, home_html=None):
# 实例化 ConfigParser 并加载配置文件
conf = SafeConfigParser()
# 从配置文件读取并分析（分列）配置信息
conf.readfp(open(configpath))
# TODO - be able to supply in config as well
self.home_html = home_html
self.conf = conf
if fonts:
# 注册指定字体
mapnik.register_fonts(fonts)
if mapfile:
# 生成BaseWMSFactory实例
wms_factory = BaseWMSFactory(configpath)
# TODO - add support for Cascadenik MML
wms_factory.loadXML(mapfile)
wms_factory.finalize()
self.mapfactory = wms_factory
else:
# 阅读default.conf,有疑惑???
#
# 原default.conf文件中module未定义,需要使用要在default.conf中自行定义
if not conf.has_option_with_value('server', 'module'):
raise ServerConfigurationError(
'The factory module is not defined in the configuration file.'
)
# 导入指定module
try:
# get(section，option)，Get an option value for the named
# section.
mapfactorymodule = do_import(conf.get('server', 'module'))
except ImportError:
raise ServerConfigurationError(
'The factory module could not be loaded.')
if hasattr(mapfactorymodule, 'WMSFactory'):
# Get a named attribute from an object; getattr(x, 'y') is
# equivalent to x.y.
self.mapfactory = getattr(mapfactorymodule, 'WMSFactory')()
else:
raise ServerConfigurationError(
'The factory module does not have a WMSFactory class.')
if conf.has_option('server', 'debug'):
self.debug = int(conf.get('server', 'debug'))
else:
self.debug = 0
if self.conf.has_option_with_value('server', 'maxage'):
self.max_age = 'max-age=%d' % self.conf.get('server', 'maxage')
else:
self.max_age = None
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')
import cherrypy
import psycopg2
import mapnik
import pylibmc
import data_timestamp
# ----------------------------
tile_size = 256
pq_time_fmt = '%Y-%m-%d %H:%M:%S'
current_dir = os.path.dirname(os.path.abspath(__file__))
mapnik.register_fonts('/zdata/osm/font')
mapnik.register_fonts('/usr/local/lib/X11/fonts')
mapnik.register_fonts('/usr/local/share/fonts')
# ----------------------------
# hack to make cherrypy to output sub-second log
# modified from _cplogging.py
def time_hack(self):
"""Return now() in Apache Common Log Format (no timezone)."""
now = datetime.datetime.now()
monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun',
'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
month = monthnames[now.month - 1].capitalize()
return ('[%02d/%s/%04d:%02d:%02d:%02d.%06d]' %
(now.day, month, now.year, now.hour, now.minute, now.second, now.microsecond))
apg_db.add_argument('--host', help='database host', default=None)
apg_db.add_argument('--port', type=int, help='database port', default='5432')
apg_db.add_argument('-u', '--user', help='user name for db (default: {0})'.format(default_user), default=default_user)
apg_db.add_argument('-w', '--password', action='store_true', help='ask for password', default=False)
options = parser.parse_args()
# check for required argument
if options.bbox == None and options.poly == None and (not HAS_PSYCOPG or (options.cities == None and options.area == None)) and options.list == None:
parser.print_help()
sys.exit()
# custom fonts
if(options.customfonts):
from mapnik import register_fonts, FontEngine
#custom_fonts_dir = '../../../fonts/'
register_fonts(options.customfonts);
# writer
if options.tiledir:
writer = FileWriter(options.tiledir, format=options.format, tms=options.tms, overwrite=not options.skip_existing, deleteempty= options.delete_empty)
elif HAS_SQLITE and options.mbtiles:
writer = multi_MBTilesWriter(options.threads, options.mbtiles, options.name, overlay=options.overlay, format=options.format)
elif options.export:
writer = ListWriter(options.export)
else:
writer = FileWriter(os.getcwd() + '/tiles', format=options.format, tms=options.tms, overwrite=not options.skip_existing)
# input and process
poly = None
if options.bbox:
b = options.bbox
from math import pi,cos,sin,log,exp,atan
from subprocess import call
import sys, os
from Queue import Queue
import threading
import mapnik
DEG_TO_RAD = pi/180
RAD_TO_DEG = 180/pi
# Default number of rendering threads to spawn, should be roughly equal to number of CPU cores available
NUM_THREADS = 2
custom_fonts_dir = '/Library/Fonts/'
mapnik.register_fonts(custom_fonts_dir)
from optparse import OptionParser
parser = OptionParser()
parser.add_option("--dir",dest="rep",help="DIR")
parser.add_option("--zmin",dest="zoomin",help="ZOOMIN")
parser.add_option("--zmax",dest="zoomax",help="ZOOMAX")
(options,args) = parser.parse_args()
dir=options.rep
zmin=options.zoomin
zmax=options.zoomax
def render_to_wld(map, path, x_rotation=0.0, y_rotation=0.0):
"""
Outputs an ESRI world file that can be used to load the resulting
image as a georeferenced raster in a variety of gis viewers.
from env import *
from coords import *
from common import *
import NED
import areas
from JobManager import JobManager
__author__ = "Lars Ahlzen and contributors"
__copyright__ = "(c) Lars Ahlzen and contributors 2008-2011"
__license__ = "GPLv2"
##### Initialize Mapnik
# Import extra fonts
if EXTRA_FONTS_DIR != '':
mapnik.register_fonts(EXTRA_FONTS_DIR)
# Check for cairo support
if not mapnik.has_cairo():
print "ERROR: Your mapnik does not have Cairo support."
sys.exit(1)
##### Render settings
# Set to true to save intermediate layers that are normally
# merged. Primarily useful for debugging and style editing.
SAVE_INTERMEDIATE_TILES = False
# Enables/disables saving the composite layers
SAVE_PNG_COMPOSITE = True
SAVE_JPEG_COMPOSITE = True
import sys
from .cartographer import Cartographer
try:
# From mapnik 2.0.1, module name mapnik2 is deprecated
import mapnik
except ImportError:
# In case of mapnik 2.0.0 or 0.7.x
import mapnik2 as mapnik
MAPNIK_VERSION = mapnik.mapnik_version() / 100000
# Automatically add system font directory
if sys.platform == 'darwin':
mapnik.register_fonts(r'/Library/Fonts/')
elif sys.platform == 'linux2':
mapnik.register_fonts(r'/usr/share/fonts')
elif sys.platform == 'win32':
mapnik.register_fonts(r'C:\Windows\Fonts')
# for face in list(mapnik.FontEngine.face_names()):
# print face
#==============================================================================
# Render maps using mapnik
#==============================================================================
class Mapnik(Cartographer):
""" Mapnik Renderer
map_major_grid_idx = map_ref_idx[0:2]
map_minor_grid_idx = map_ref_idx
# Generate symbols
print('Creating symbols...')
call("../symbols.sh " + map_ref_idx, shell=True)
print('Finished creating symbols')
# Convert MML to XML
print('Creating XML file...')
call("carto grough_map.mml > grough_map.xml", shell=True)
stylesheet = 'grough_map.xml'
# Custom fonts
print('Registering typefaces...')
register_fonts('/vagrant/source/typefaces/')
for face in font.face_names():
print('...' + face)
# Connect to the database
#pg_conn_string = "host='localhost' dbname='grough' user='******' password='******'"
pg_conn_string = "host='localhost' dbname='grough-map' user='******'"
print('Connecting to PG database...')
pg_conn = psycopg2.connect(pg_conn_string)
pg_cursor = pg_conn.cursor()
print('Connected to database.')
print('Target grid square is ', map_ref_idx, '...')
print('Target major grid is ', map_major_grid_idx, '...')
print('Target file is ', map_target, '...')
if not os.path.isdir(tile_dir + zoom + '/' + str_x):
os.mkdir(tile_dir + zoom + '/' + str_x)
for y in range(int(px0[1] / 256.0), int(px1[1] / 256.0) + 1):
# Validate x co-ordinate
if (y < 0) or (y >= 2**z):
continue
str_y = "%s" % y
tile_uri = tile_dir + zoom + '/' + str_x + '/' + str_y + '.png'
# Submit tile to be rendered into the queue
render_tile(tile_uri, x, y, z)
print(zoom + ' ' + str_x + ' ' + str_y)
m = mapnik.Map(2800, 1800)
mapnik.load_map(m, 'stylesheet.xml')
mapnik.register_fonts('/fonts')
# http://en.wikipedia.org/wiki/Extreme_points_of_the_United_States#Westernmost
# TODO: switch this to include all 50 states
top = 49.3457868 # north lat
left = -124.7844079 # west long
right = -66.9513812 # east long
bottom = 24.7433195 # south lat
bbox = (left, bottom, right, top)
prj = mapnik.Projection(m.srs)
tileproj = GoogleProjection()
render_tiles(bbox, '/output/counties/', minZoom=7, maxZoom=9)
def main():
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = os.getcwd() + '/osm.xml'
default_user = getpass.getuser()
parser = argparse.ArgumentParser(description='Generate mapnik tiles for an OSM polygon')
apg_input = parser.add_argument_group('Input')
apg_input.add_argument("-b", "--bbox", nargs=4, type=float, metavar=('X1', 'Y1', 'X2', 'Y2'), help="generate tiles inside a bounding box")
apg_input.add_argument('-p', '--poly', type=argparse.FileType('r'), help='use a poly file for area')
if HAS_PSYCOPG:
apg_input.add_argument("-a", "--area", type=int, metavar='OSM_ID', help="generate tiles inside an OSM polygon: positive for polygons, negative for relations, 0 for whole database")
apg_input.add_argument("-c", "--cities", type=int, metavar='OSM_ID', help='generate tiles for all towns inside a polygon')
apg_input.add_argument('-l', '--list', type=argparse.FileType('r'), metavar='TILES.LST', help='process tile list')
apg_output = parser.add_argument_group('Output')
apg_output.add_argument('-t', '--tiledir', metavar='DIR', help='output tiles to directory (default: {0}/tiles)'.format(os.getcwd()))
apg_output.add_argument('--tms', action='store_true', help='write files in TMS order', default=False)
if HAS_SQLITE:
apg_output.add_argument('-m', '--mbtiles', help='generate mbtiles file')
apg_output.add_argument('--name', help='name for mbtiles', default='Test MBTiles')
apg_output.add_argument('--overlay', action='store_true', help='if this layer is an overlay (for mbtiles metadata)', default=False)
apg_output.add_argument('-x', '--export', type=argparse.FileType('w'), metavar='TILES.LST', help='save tile list into file')
apg_output.add_argument('-z', '--zooms', type=int, nargs=2, metavar=('ZMIN', 'ZMAX'), help='range of zoom levels to render (default: 6 12)', default=(6, 12))
apg_other = parser.add_argument_group('Settings')
apg_other.add_argument('-s', '--style', help='style file for mapnik (default: {0})'.format(mapfile), default=mapfile)
apg_other.add_argument('-f', '--format', default='png256', help='tile image format (default: png256)')
apg_other.add_argument('--meta', type=int, default=8, metavar='N', help='metatile size NxN tiles (default: 8)')
apg_other.add_argument('--scale', type=float, default=1.0, help='scale factor for HiDpi tiles (affects tile size)')
apg_other.add_argument('--threads', type=int, metavar='N', help='number of threads (default: 2)', default=2)
apg_other.add_argument('--skip-existing', action='store_true', default=False, help='do not overwrite existing files')
apg_other.add_argument('--fonts', help='directory with custom fonts for the style')
apg_other.add_argument('--for-renderd', action='store_true', default=False, help='produce only a single tile for metatiles')
apg_other.add_argument('-q', '--quiet', dest='verbose', action='store_false', help='do not print any information', default=True)
if HAS_PSYCOPG:
apg_db = parser.add_argument_group('Database (for poly/cities)')
apg_db.add_argument('-d', '--dbname', metavar='DB', help='database (default: gis)', default='gis')
apg_db.add_argument('--host', help='database host', default=None)
apg_db.add_argument('--port', type=int, help='database port', default='5432')
apg_db.add_argument('-u', '--user', help='user name for db (default: {0})'.format(default_user), default=default_user)
apg_db.add_argument('-w', '--password', action='store_true', help='ask for password', default=False)
options = parser.parse_args()
# check for required argument
if not options.bbox and not options.poly and (not HAS_PSYCOPG or (not options.cities and not options.area)) and not options.list:
parser.print_help()
sys.exit(1)
if options.verbose:
log_level = logging.INFO
else:
log_level = logging.WARNING
logging.basicConfig(level=log_level, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')
# custom fonts
if options.fonts:
mapnik.register_fonts(options.fonts)
# writer
if options.tiledir:
writer = FileWriter(options.tiledir, format=options.format,
tms=options.tms, overwrite=not options.skip_existing)
elif HAS_SQLITE and options.mbtiles:
writer = multi_MBTilesWriter(options.threads, options.mbtiles, options.name,
overlay=options.overlay, format=options.format)
elif options.export:
writer = ListWriter(options.export)
else:
writer = FileWriter(os.getcwd() + '/tiles', format=options.format,
tms=options.tms, overwrite=not options.skip_existing)
# input and process
poly = None
if options.bbox:
b = options.bbox
poly = box(b[0], b[1], b[2], b[3])
if options.poly:
tpoly = poly_parse(options.poly)
poly = tpoly if not poly else poly.intersection(tpoly)
if HAS_PSYCOPG and (options.area or options.cities):
passwd = None
if options.password:
passwd = getpass.getpass("Please enter your password: "******"Error connecting to database: %s", e.pgerror or e)
sys.exit(3)
if options.list:
generator = ListGenerator(options.list, metatile=options.meta)
elif poly:
generator = PolyGenerator(poly, list(range(options.zooms[0], options.zooms[1] + 1)),
metatile=options.meta)
else:
logging.error("Please specify a region for rendering.")
sys.exit(4)
if options.threads > 1 and writer.multithreading():
render_tiles_multithreaded(generator, options.style, writer,
num_threads=options.threads,
scale=options.scale, renderlist=options.for_renderd)
else:
render_tiles(generator, options.style, writer,
scale=options.scale, renderlist=options.for_renderd)
writer.close()
#!/usr/bin/env python
import mapnik
import sys, os
from mapnik import register_fonts, FontEngine
custom_fonts_dir = '../../../fonts/'
register_fonts(custom_fonts_dir)
# 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__":
mapfile = "../../tilestyles/mazda/mazda.xml"
map_uri = "image.png"
from mapnik import register_fonts, FontEngine custom_fonts_dir = '/Users/thomas/Library/Fonts' register_fonts(custom_fonts_dir) for face in FontEngine.face_names(): print face
apg_db.add_argument('--host', help='database host', default=None)
apg_db.add_argument('--port', type=int, help='database port', default='5432')
apg_db.add_argument('-u', '--user', help='user name for db (default: {0})'.format(default_user), default=default_user)
apg_db.add_argument('-w', '--password', action='store_true', help='ask for password', default=False)
options = parser.parse_args()
# check for required argument
if options.bbox == None and options.poly == None and (not HAS_PSYCOPG or (options.cities == None and options.area == None)) and options.list == None:
parser.print_help()
sys.exit()
# custom fonts
if(options.customfonts):
from mapnik import register_fonts, FontEngine
#custom_fonts_dir = '../../../fonts/'
register_fonts(options.customfonts);
# writer
if options.tiledir:
writer = FileWriter(options.tiledir, format=options.format, tms=options.tms, overwrite=not options.skip_existing, deleteempty= options.delete_empty)
elif HAS_SQLITE and options.mbtiles:
writer = multi_MBTilesWriter(options.threads, options.mbtiles, options.name, overlay=options.overlay, format=options.format)
elif options.export:
writer = ListWriter(options.export)
else:
writer = FileWriter(os.getcwd() + '/tiles', format=options.format, tms=options.tms, overwrite=not options.skip_existing)
# input and process
poly = None
if options.bbox:
b = options.bbox
def main():
try:
mapfile = os.environ['MAPNIK_MAP_FILE']
except KeyError:
mapfile = os.getcwd() + '/osm.xml'
default_user = getpass.getuser()
parser = argparse.ArgumentParser(
description='Generate mapnik tiles for an OSM polygon')
apg_input = parser.add_argument_group('Input')
apg_input.add_argument("-b",
"--bbox",
nargs=4,
type=float,
metavar=('X1', 'Y1', 'X2', 'Y2'),
help="generate tiles inside a bounding box")
apg_input.add_argument('-p',
'--poly',
type=argparse.FileType('r'),
help='use a poly file for area')
if HAS_PSYCOPG:
apg_input.add_argument(
"-a",
"--area",
type=int,
metavar='OSM_ID',
help=
"generate tiles inside an OSM polygon: positive for polygons, negative for relations, 0 for whole database"
)
apg_input.add_argument(
"-c",
"--cities",
type=int,
metavar='OSM_ID',
help='generate tiles for all towns inside a polygon')
apg_input.add_argument('-l',
'--list',
type=argparse.FileType('r'),
metavar='TILES.LST',
help='process tile list')
apg_output = parser.add_argument_group('Output')
apg_output.add_argument(
'-t',
'--tiledir',
metavar='DIR',
help='output tiles to directory (default: {0}/tiles)'.format(
os.getcwd()))
apg_output.add_argument('--tms',
action='store_true',
help='write files in TMS order',
default=False)
if HAS_SQLITE:
apg_output.add_argument('-m',
'--mbtiles',
help='generate mbtiles file')
apg_output.add_argument('--name',
help='name for mbtiles',
default='Test MBTiles')
apg_output.add_argument(
'--overlay',
action='store_true',
help='if this layer is an overlay (for mbtiles metadata)',
default=False)
apg_output.add_argument('-x',
'--export',
type=argparse.FileType('w'),
metavar='TILES.LST',
help='save tile list into file')
apg_output.add_argument(
'-z',
'--zooms',
type=int,
nargs=2,
metavar=('ZMIN', 'ZMAX'),
help='range of zoom levels to render (default: 6 12)',
default=(6, 12))
apg_other = parser.add_argument_group('Settings')
apg_other.add_argument(
'-s',
'--style',
help='style file for mapnik (default: {0})'.format(mapfile),
default=mapfile)
apg_other.add_argument('-f',
'--format',
default='png256',
help='tile image format (default: png256)')
apg_other.add_argument('--meta',
type=int,
default=8,
metavar='N',
help='metatile size NxN tiles (default: 8)')
apg_other.add_argument(
'--scale',
type=float,
default=1.0,
help='scale factor for HiDpi tiles (affects tile size)')
apg_other.add_argument('--threads',
type=int,
metavar='N',
help='number of threads (default: 2)',
default=2)
apg_other.add_argument('--skip-existing',
action='store_true',
default=False,
help='do not overwrite existing files')
apg_other.add_argument('--fonts',
help='directory with custom fonts for the style')
apg_other.add_argument('--for-renderd',
action='store_true',
default=False,
help='produce only a single tile for metatiles')
apg_other.add_argument('-q',
'--quiet',
dest='verbose',
action='store_false',
help='do not print any information',
default=True)
if HAS_PSYCOPG:
apg_db = parser.add_argument_group('Database (for poly/cities)')
apg_db.add_argument('-d',
'--dbname',
metavar='DB',
help='database (default: gis)',
default='gis')
apg_db.add_argument('--host', help='database host', default=None)
apg_db.add_argument('--port',
type=int,
help='database port',
default='5432')
apg_db.add_argument(
'-u',
'--user',
help='user name for db (default: {0})'.format(default_user),
default=default_user)
apg_db.add_argument('-w',
'--password',
action='store_true',
help='ask for password',
default=False)
options = parser.parse_args()
# check for required argument
if not options.bbox and not options.poly and (
not HAS_PSYCOPG or
(not options.cities and not options.area)) and not options.list:
parser.print_help()
sys.exit(1)
if options.verbose:
log_level = logging.INFO
else:
log_level = logging.WARNING
logging.basicConfig(level=log_level,
format='%(asctime)s %(message)s',
datefmt='%H:%M:%S')
# custom fonts
if options.fonts:
mapnik.register_fonts(options.fonts)
# writer
if options.tiledir:
writer = FileWriter(options.tiledir,
format=options.format,
tms=options.tms,
overwrite=not options.skip_existing)
elif HAS_SQLITE and options.mbtiles:
writer = multi_MBTilesWriter(options.threads,
options.mbtiles,
options.name,
overlay=options.overlay,
format=options.format)
elif options.export:
writer = ListWriter(options.export)
else:
writer = FileWriter(os.getcwd() + '/tiles',
format=options.format,
tms=options.tms,
overwrite=not options.skip_existing)
# input and process
poly = None
if options.bbox:
b = options.bbox
poly = box(b[0], b[1], b[2], b[3])
if options.poly:
tpoly = poly_parse(options.poly)
poly = tpoly if not poly else poly.intersection(tpoly)
if HAS_PSYCOPG and (options.area or options.cities):
passwd = None
if options.password:
passwd = getpass.getpass("Please enter your password: "******"Error connecting to database: %s", e.pgerror or e)
sys.exit(3)
if options.list:
generator = ListGenerator(options.list, metatile=options.meta)
elif poly:
generator = PolyGenerator(poly,
list(
range(options.zooms[0],
options.zooms[1] + 1)),
metatile=options.meta)
else:
logging.error("Please specify a region for rendering.")
sys.exit(4)
if options.threads > 1 and writer.multithreading():
render_tiles_multithreaded(generator,
options.style,
writer,
num_threads=options.threads,
scale=options.scale,
renderlist=options.for_renderd)
else:
render_tiles(generator,
options.style,
writer,
scale=options.scale,
renderlist=options.for_renderd)
writer.close()
def add_fonts(path):
if os.path.exists(path):
mapnik.register_fonts(path)
else:
raise Exception('The directory "{p}" does not exists'.format(p=path))
z = int(args.lonlat[0])
lonx = float(args.lonlat[1])
laty = float(args.lonlat[2])
x, y = deg2num(lonx, laty, z)
if args.zxy:
z = int(args.zxy[0])
x = int(args.zxy[1])
y = int(args.zxy[2])
if args.time:
start = time.time()
import mapnik
custom_fonts_dir = '/etc/mapnik-osm-data/fonts/'
mapnik.register_fonts(custom_fonts_dir)
m = mapnik.Map(256, 256)
mapnik.load_map(m, mapfile)
bba = TileToBBox(x, y, z)
bbox = mapnik.Box2d(bba[0], bba[1], bba[2], bba[3])
m.zoom_to_box(bbox)
im = mapnik.Image(256, 256)
mapnik.render(m, im)
if args.outputfile:
ofile = args.outputfile
else:
ofile = args.prefix + '-' + str(z) + '-' + str(x) + '-' + str(
y) + '.png'
if ofile != '-':
f = open(ofile, 'w')
def addCustomFonts(self, customFontsDir):
'''
Picks the font that the labels are written in.
'''
register_fonts(customFontsDir)
import json
import cairo
from io import BytesIO
from mapnik import Map, Projection, ProjTransform, Box2d, load_map, \
load_map_from_string, render, register_fonts
from flask import current_app
from geojson import FeatureCollection, Feature, Point
from timeit import default_timer as timer
from app.utils import get_xml, strip
register_fonts('/usr/share/fonts')
class MapRenderer:
""" Class for rendering maps through mapnik """
def __init__(self, content):
""" With MapRenderer you can render an aktionskarten map in different
file formats like pdf, svg or png.
Internally it uses mapnik and cairo to archieve this. A valid style
has to be defined through `MAPNIK_OSM_XML`. Normally this a carto
derived `style.xml`. In this file your datasource is specified. This
can be for instance a postgres+postgis database with imported osm
data.
:param content: dict of map content
"""
# Mapnik uses mercator as internal projection. Our data is encoded in
# latlon. Therefor we need a transformer for coordindates from longlat
def __init__(self, config_files=None):
"""Instanciate a new configured OCitySMap instance.
Args:
config_file (string or list or None): path, or list of paths to
the OCitySMap configuration file(s). If None, sensible defaults
are tried.
"""
if config_files is None:
config_files = ['/etc/ocitysmap.conf', '~/.ocitysmap.conf']
elif not isinstance(config_files, list):
config_files = [config_files]
config_files = set(map(os.path.expanduser, config_files))
LOG.debug('Reading OCitySMap configuration from %s...' %
', '.join(config_files))
self._parser = configparser.ConfigParser()
self._parser.optionxform = str # make option names case sensitive
if not self._parser.read(config_files, encoding='utf-8'):
raise IOError('None of the configuration files could be read!')
self._locale_path = os.path.join(os.path.dirname(__file__), '..',
'locale')
self.__dbs = {}
# Read stylesheet configuration
self.STYLESHEET_REGISTRY = Stylesheet.create_all_from_config(
self._parser)
if not self.STYLESHEET_REGISTRY:
raise ValueError( \
'OCitySMap configuration does not contain any stylesheet!')
LOG.debug('Found %d Mapnik stylesheets.' %
len(self.STYLESHEET_REGISTRY))
self.OVERLAY_REGISTRY = Stylesheet.create_all_from_config(
self._parser, "overlays")
LOG.debug('Found %d Mapnik overlay styles.' %
len(self.OVERLAY_REGISTRY))
# register additional font path directories if set
try:
font_path = self._parser.get('rendering', 'font_path')
for font_dir in font_path.split(os.pathsep):
mapnik.register_fonts(font_dir)
except configparser.NoOptionError:
pass
r_paper = re.compile('^\s*(\d+)\s*x\s*(\d+)\s*$')
if self._parser.has_section('paper_sizes'):
self.PAPER_SIZES = []
for key in self._parser['paper_sizes']:
value = self._parser['paper_sizes'][key]
try:
(w, h) = r_paper.match(value).groups()
self.PAPER_SIZES.append((key, int(w), int(h)))
except:
LOG.warning(
"Ignoring invalid paper size '%s' for format '%s'" %
(key, value))
else:
# minimal fallback configuration
self.PAPER_SIZES = [
('DinA4', 210, 297),
('US_letter', 216, 279),
]
self.PAPER_SIZES.append(('Best fit', None, None))
self.PAPER_SIZES.append(('Custom', None, None))
if self._parser.has_section('multipage_paper_sizes'):
self.MULTIPAGE_PAPER_SIZES = []
for key in self._parser['multipage_paper_sizes']:
value = self._parser['multipage_paper_sizes'][key]
try:
(w, h) = r_paper.match(value).groups()
self.MULTIPAGE_PAPER_SIZES.append((key, int(w), int(h)))
except Exception as e:
LOG.warning(
"Ignoring invalid paper size '%s' for multi page format '%s'"
% (key, value))
else:
# minimal fallback configuration
self.MULTIPAGE_PAPER_SIZES = [
('DinA4', 210, 297),
('US_letter', 216, 279),
]
def add_fonts(path):
if os.path.exists(path):
mapnik.register_fonts(path)
else:
raise Exception('The directory "{p}" does not exists'.format(p=path))
def addCustomFonts(self, customFontsDir):
'''
Picks the font that the labels are written in.
'''
register_fonts(customFontsDir)
