def draw_map_centered (self) :
provider = self.load_provider(self.ctx['provider'])
loc = ModestMaps.Geo.Location(self.ctx['latitude'], self.ctx['longitude'])
dim = ModestMaps.Core.Point(self.ctx['width'], self.ctx['height'])
zoom = self.ctx['zoom']
self.ctx['map'] = ModestMaps.mapByCenterZoom(provider, loc, zoom, dim)
return self.ctx['map'].draw()
def draw_map_centered(self):
provider = self.load_provider(self.ctx['provider'])
loc = ModestMaps.Geo.Location(self.ctx['latitude'],
self.ctx['longitude'])
dim = ModestMaps.Core.Point(self.ctx['width'], self.ctx['height'])
zoom = self.ctx['zoom']
self.ctx['map'] = ModestMaps.mapByCenterZoom(provider, loc, zoom, dim)
return self.ctx['map'].draw()
def get_mmap_page(mmap, row, col, rows, cols):
""" Get a mmap instance for a sub-page in an atlas layout.
"""
dim = mmap.dimensions
# aim for ~5% overlap, vary dep. on total rows/cols
overlap = 0.1 / rows
overlap *= (dim.x + dim.y) / 2
# inner width and height of sub-page
_w = (dim.x - (cols + 1) * overlap) / cols
_h = (dim.y - (rows + 1) * overlap) / rows
# pixel offset of page center
x = (col * _w) + (_w / 2) + (col * overlap) + overlap
y = (row * _h) + (_h / 2) + (row * overlap) + overlap
location = mmap.pointLocation(mm.Core.Point(x, y))
zoom = mmap.coordinate.zoom + (log(rows) / log(2))
return mm.mapByCenterZoom(mmap.provider, location, zoom, mmap.dimensions)
)
elif options.extent and options.dimensions and options.zoom:
raise BadComposure(
"Error: bad map coverage, dimensions and zoom can't be set together with extent."
)
elif options.center and options.zoom and options.dimensions:
lat, lon = options.center[0], options.center[1]
width, height = options.dimensions[0], options.dimensions[1]
dimensions = ModestMaps.Core.Point(width, height)
center = ModestMaps.Geo.Location(lat, lon)
zoom = options.zoom
map = ModestMaps.mapByCenterZoom(provider, center, zoom,
dimensions)
elif options.extent and options.dimensions:
latA, lonA = options.extent[0], options.extent[1]
latB, lonB = options.extent[2], options.extent[3]
width, height = options.dimensions[0], options.dimensions[1]
dimensions = ModestMaps.Core.Point(width, height)
locationA = ModestMaps.Geo.Location(latA, lonA)
locationB = ModestMaps.Geo.Location(latB, lonB)
map = ModestMaps.mapByExtent(provider, locationA, locationB,
dimensions)
elif options.extent and options.zoom:
latA, lonA = options.extent[0], options.extent[1]
dimensions = ModestMaps.Core.Point(*opts.size)
format = output[-4:]
assert zoom >= 0 and zoom <= 18
assert format in ('.png', '.jpg')
for ttf in glob.glob(os.path.join(fonts, '*.ttf')):
mapnik.FontEngine.register_font(ttf)
except Exception, e:
print >> sys.stderr, e
print >> sys.stderr, 'Usage: python mapnik-render.py <fonts dir> <stylesheet> <lat> <lon> <zoom> <width> <height> <output jpg/png>'
sys.exit(1)
osm = ModestMaps.OpenStreetMap.Provider()
map = ModestMaps.mapByCenterZoom(osm, center, zoom, dimensions)
srs = {'proj': 'merc', 'a': 6378137, 'b': 6378137, 'lat_0': 0, 'lon_0': 0, 'k': 1.0, 'units': 'm', 'nadgrids': '@null', 'no_defs': True}
gym = pyproj.Proj(srs)
northwest = map.pointLocation(ModestMaps.Core.Point(0, 0))
southeast = map.pointLocation(dimensions)
left, top = gym(northwest.lon, northwest.lat)
right, bottom = gym(southeast.lon, southeast.lat)
map = mapnik.Map(dimensions.x, dimensions.y)
mapnik.load_map(map, stylesheet)
map.zoom_to_box(mapnik.Envelope(left, top, right, bottom))
img = mapnik.Image(dimensions.x, dimensions.y)
# Requires ModestMaps to be installed
# Don't do this unless you have a very good reason, and a MapBox account,
# and you replace the 'examples' tileset with a tileset in your account.
import ModestMaps as MM
from ModestMaps.Geo import MercatorProjection, deriveTransformation
from ModestMaps.Providers import IMapProvider
from math import pi
class MapBox(IMapProvider):
def __init__(self):
t = deriveTransformation(-pi, pi, 0, 0, pi, pi, 1, 0, -pi, -pi, 0, 1)
self.projection = MercatorProjection(0, t)
def tileWidth(self):
return 256
def tileHeight(self):
return 256
def getTileUrls(self, coordinate):
return (
'http://api.tiles.mapbox.com/v3/examples.map-vyofok3q/%d/%d/%d.png'
% (coordinate.zoom, coordinate.column, coordinate.row), )
m = MM.mapByCenterZoom(MapBox(), MM.Geo.Location(37.8, -78), 13,
MM.Core.Point(1200, 600))
m.draw().save('map.png')
dimensions = ModestMaps.Core.Point(*opts.size)
format = output.split(".").pop().lower()
assert zoom >= 0 and zoom <= 19
assert format in ('png', 'jpg', 'svg', 'pdf', 'ps')
for ttf in glob.glob(os.path.join(fonts, '*.ttf')):
mapnik.FontEngine.register_font(ttf)
except Exception, e:
print >> sys.stderr, e
print >> sys.stderr, 'Usage: python mapnik-render.py <fonts dir> <stylesheet> <lat> <lon> <zoom> <width> <height> <output jpg/png/svg/pdf/ps>'
sys.exit(1)
osm = ModestMaps.OpenStreetMap.Provider()
map = ModestMaps.mapByCenterZoom(osm, center, zoom, dimensions)
srs = {
'proj': 'merc',
'a': 6378137,
'b': 6378137,
'lat_0': 0,
'lon_0': 0,
'k': 1.0,
'units': 'm',
'nadgrids': '@null',
'no_defs': True
}
gym = pyproj.Proj(srs)
northwest = map.pointLocation(ModestMaps.Core.Point(0, 0))
if options.center and options.extent:
raise BadComposure("Error: bad map coverage, center and extent can't both be set.")
elif options.extent and options.dimensions and options.zoom:
raise BadComposure("Error: bad map coverage, dimensions and zoom can't be set together with extent.")
elif options.center and options.zoom and options.dimensions:
lat, lon = options.center[0], options.center[1]
width, height = options.dimensions[0], options.dimensions[1]
dimensions = ModestMaps.Core.Point(width, height)
center = ModestMaps.Geo.Location(lat, lon)
zoom = options.zoom
map = ModestMaps.mapByCenterZoom(provider, center, zoom, dimensions)
elif options.extent and options.dimensions:
latA, lonA = options.extent[0], options.extent[1]
latB, lonB = options.extent[2], options.extent[3]
width, height = options.dimensions[0], options.dimensions[1]
dimensions = ModestMaps.Core.Point(width, height)
locationA = ModestMaps.Geo.Location(latA, lonA)
locationB = ModestMaps.Geo.Location(latB, lonB)
map = ModestMaps.mapByExtent(provider, locationA, locationB, dimensions)
elif options.extent and options.zoom:
latA, lonA = options.extent[0], options.extent[1]
latB, lonB = options.extent[2], options.extent[3]
def make_map(provider, area, zoom, by_centre, map_size=(1200,800), verbose=False):
"""
zoom: integer, the zoom level (altitude)
min 12; max 15 in this case
Returns a map instance (not image!)
"""
if type(area) in (str, unicode):
area = area.lower()
zoom = int(zoom)
provider = PROVIDERS[provider.lower()]
if verbose:
title = 'Making map with the following characteristics:'
print '\n%s' % title
print '-' * len(title)
if type(area) in (str, unicode):
print 'Area: %s' % area.title()
else:
print 'Area: %s' % area
print 'Zoom: %d' % zoom
if type(provider) == str:
print 'Provider: %s' % provider.title().replace('_', ' ')
else:
print 'Provider: %s' % provider.__name__
print 'Height: %dpx' % map_size[1]
print 'Width: %dpx' % map_size[0]
print
if type(provider) == str:
provider = MM.builtinProviders[provider]()
else: # it must be a custom provider
provider = provider()
if by_centre:
if type(area) in (str, unicode):
centre = CENTRE[area]
elif type(area) == tuple:
centre = area
width = map_size[0]
height = map_size[1]
m = MM.mapByCenterZoom( provider,
MM.Geo.Location(*centre),
zoom,
MM.Core.Point(width, height))
if verbose:
print m.pointLocation(MM.Core.Point(0,0)) # to get the upper left corner geo coordinates
print m.pointLocation(MM.Core.Point(width,height)) # to get the lower right corner geo coordinates
else: # by box
if type(area) in (str, unicode):
map_box = MAP_BOX[area]
elif type(area) == tuple:
map_box = area
left_upper_corner = MM.Geo.Location(*map_box[0])
right_lower_corner = MM.Geo.Location(*map_box[1])
m = MM.mapByExtentZoom( provider,
left_upper_corner,
right_lower_corner,
zoom)
return m
def main(apibase, password, print_id, paper_size, orientation=None, layout=None, provider=None, bounds=None, zoom=None, geotiff_url=None):
"""
"""
yield 60
print 'Print:', print_id
print 'Paper:', paper_size
if orientation and bounds and zoom and provider and layout:
print 'Orientation:', orientation
print 'Bounds:', bounds
print 'Layout:', layout
print 'Provider:', provider
print 'Size:', get_preview_map_size(orientation, paper_size)
print_data = {'pages': []}
print_pages = print_data['pages']
north, west, south, east = bounds
width, height = get_preview_map_size(orientation, paper_size)
northwest = mm.Geo.Location(north, west)
southeast = mm.Geo.Location(south, east)
# we need it to cover a specific area
mmap = mm.mapByExtentZoom(TemplatedMercatorProvider(provider),
northwest, southeast, zoom)
# but we also we need it at a specific size
mmap = mm.Map(mmap.provider, mm.Core.Point(width, height), mmap.coordinate, mmap.offset)
out = StringIO()
mmap.draw(fatbits_ok=True).save(out, format='JPEG')
preview_url = append_print_file(print_id, 'preview.jpg', out.getvalue(), apibase, password)
print 'Sent preview.jpg'
yield 60
zdiff = min(18, zoom + 2) - zoom
print 'Zoom diff:', zdiff
# we need it to cover a specific area
mmap = mm.mapByExtentZoom(TemplatedMercatorProvider(provider),
northwest, southeast, zoom + zdiff)
# but we also we need it at a specific size
mmap = mm.Map(mmap.provider, mm.Core.Point(width * 2**zdiff, height * 2**zdiff), mmap.coordinate, mmap.offset)
out = StringIO()
mmap.draw(fatbits_ok=True).save(out, format='JPEG')
print_url = append_print_file(print_id, 'print.jpg', out.getvalue(), apibase, password)
print 'Sent print.jpg'
page_nw = mmap.pointLocation(mm.Core.Point(0, 0))
page_se = mmap.pointLocation(mmap.dimensions)
page_data = {'print': 'print.jpg', 'preview': 'preview.jpg', 'bounds': {}}
page_data['bounds'].update({'north': page_nw.lat, 'west': page_nw.lon})
page_data['bounds'].update({'south': page_se.lat, 'east': page_se.lon})
print_pages.append(page_data)
rows, cols = map(int, layout.split(','))
if rows > 1 and cols > 1:
for (row, col) in product(range(rows), range(cols)):
yield 60
sub_mmap = get_mmap_page(mmap, row, col, rows, cols)
sub_part = '%(row)d,%(col)d' % locals()
sub_name = 'print-%(sub_part)s.jpg' % locals()
out = StringIO()
sub_mmap.draw(fatbits_ok=True).save(out, format='JPEG')
append_print_file(print_id, sub_name, out.getvalue(), apibase, password)
print 'Sent', sub_name
prev_cen = sub_mmap.pointLocation(mm.Core.Point(sub_mmap.dimensions.x / 2, sub_mmap.dimensions.y / 2))
prev_dim = mm.Core.Point(sub_mmap.dimensions.x / 2**zdiff, sub_mmap.dimensions.y / 2**zdiff)
prev_mmap = mm.mapByCenterZoom(sub_mmap.provider, prev_cen, sub_mmap.coordinate.zoom - zdiff, prev_dim)
prev_name = 'preview-%(sub_part)s.jpg' % locals()
out = StringIO()
prev_mmap.draw(fatbits_ok=True).save(out, format='JPEG')
append_print_file(print_id, prev_name, out.getvalue(), apibase, password)
print 'Sent', prev_name
page_nw = sub_mmap.pointLocation(mm.Core.Point(0, 0))
page_se = sub_mmap.pointLocation(sub_mmap.dimensions)
page_data = {'part': sub_part, 'print': sub_name, 'preview': prev_name, 'bounds': {}}
page_data['bounds'].update({'north': page_nw.lat, 'west': page_nw.lon})
page_data['bounds'].update({'south': page_se.lat, 'east': page_se.lon})
print_pages.append(page_data)
print_data_url = append_print_file(print_id, 'print-data.json', json.dumps(print_data, indent=2), apibase, password)
print 'Sent', print_data_url
elif geotiff_url:
# we'll need pages_data, a few other things
raise Exception("I'm pretty sure support for geotiffs is currently broken, with the new atlas feature.")
print 'URL:', geotiff_url
filename = prepare_geotiff(geotiff_url)
print_img, preview_img, (north, west, south, east), orientation = adjust_geotiff(filename, paper_size)
os.unlink(filename)
print_img.save(os.path.dirname(filename)+'/out.jpg')
out = StringIO()
print_img.save(out, format='JPEG')
append_print_file(print_id, 'print.jpg', out.getvalue(), apibase, password)
out = StringIO()
preview_img.save(out, format='JPEG')
preview_url = append_print_file(print_id, 'preview.jpg', out.getvalue(), apibase, password)
zoom = infer_zoom(print_img.size[0], print_img.size[1], north, west, south, east)
else:
print 'Missing orientation, bounds, zoom, provider, layout and geotiff_url'
yield ALL_FINISHED
return
yield 10
paper = '%(orientation)s-%(paper_size)s' % locals()
print 'Finishing...'
finish_print(apibase, password, print_id, north, west, south, east, zoom, paper, print_data_url)
print '-' * 80
yield ALL_FINISHED
