desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Get mime-type and format by file extension.
This only accepts "xml".'
| def getTypeByExtension(self, extension):
| if (extension.lower() != 'xml'):
raise KnownUnknown(('TileDataOSM only makes .xml tiles, not "%s"' % extension))
return ('text/xml', 'XML')
|
'Render a single tile, return a SaveableResponse instance.'
| def renderTile(self, width, height, srs, coord):
| db = _connect(**self.dbkwargs).cursor()
prepare_database(db, coord, self.layer.projection)
counts = []
db.execute('SELECT n.id, n.version, EXTRACT(epoch FROM n.tstamp),\n u.id, u.name, n.changeset_id,\n ST_Y(n.geom), ST_X(n.geom)\n FROM nodes n\n LEFT OUTER JOIN users u\n ON n.user_id = u.id\n INNER JOIN box_node_list b\n ON b.id = n.id\n ORDER BY n.id')
nodes = [Node(*row) for row in db.fetchall()]
nodes_dict = dict([(node.id, node) for node in nodes])
db.execute('SELECT n.id, t.k, t.v\n FROM node_tags t\n INNER JOIN box_node_list n\n ON n.id = t.node_id\n ORDER BY n.id')
for (node_id, key, value) in db.fetchall():
nodes_dict[node_id].tag(key, value)
db.execute('SELECT w.id, w.version, EXTRACT(epoch FROM w.tstamp),\n u.id, u.name, w.changeset_id\n FROM ways w\n LEFT OUTER JOIN users u\n ON w.user_id = u.id\n INNER JOIN box_way_list b\n ON b.id = w.id\n ORDER BY w.id')
ways = [Way(*row) for row in db.fetchall()]
ways_dict = dict([(way.id, way) for way in ways])
db.execute('SELECT w.id, t.k, t.v\n FROM way_tags t\n INNER JOIN box_way_list w\n ON w.id = t.way_id\n ORDER BY w.id')
for (way_id, key, value) in db.fetchall():
ways_dict[way_id].tag(key, value)
db.execute('SELECT w.id, n.node_id, n.sequence_id\n FROM way_nodes n\n INNER JOIN box_way_list w\n ON n.way_id = w.id\n ORDER BY w.id, n.sequence_id')
for (way_id, node_id, sequence_id) in db.fetchall():
ways_dict[way_id].node(node_id)
db.execute('SELECT e.id, e.version, e.user_id, u.name AS user_name, e.tstamp, e.changeset_id\n FROM relations e\n LEFT OUTER JOIN users u\n ON e.user_id = u.id\n INNER JOIN box_relation_list c\n ON e.id = c.id\n ORDER BY e.id')
counts.append(len(db.fetchall()))
db.execute('SELECT relation_id AS entity_id, k, v\n FROM relation_tags f\n INNER JOIN box_relation_list c\n ON f.relation_id = c.id\n ORDER BY entity_id')
counts.append(len(db.fetchall()))
db.execute('SELECT relation_id AS entity_id, member_id, member_type, member_role, sequence_id\n FROM relation_members f\n INNER JOIN box_relation_list c\n ON f.relation_id = c.id\n ORDER BY entity_id, sequence_id')
counts.append(len(db.fetchall()))
return SaveableResponse(nodes, ways)
raise Exception(counts)
|
''
| def __init__(self, layer, filename, resample='cubic', maskband=0):
| self.layer = layer
fileurl = urljoin(layer.config.dirpath, filename)
(scheme, h, file_path, p, q, f) = urlparse(fileurl)
if (scheme not in ('', 'file')):
raise Exception(('GDAL file must be on the local filesystem, not: ' + fileurl))
if (resample not in resamplings):
raise Exception(('Resample must be "cubic", "linear", or "nearest", not: ' + resample))
self.filename = file_path
self.resample = resamplings[resample]
self.maskband = maskband
|
''
| def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
| src_ds = gdal.Open(str(self.filename))
driver = gdal.GetDriverByName('GTiff')
if src_ds.GetGCPs():
src_ds.SetProjection(src_ds.GetGCPProjection())
grayscale_src = (src_ds.RasterCount == 1)
try:
area_ds = driver.Create('/vsimem/output', width, height, 3)
if (area_ds is None):
raise Exception('uh oh.')
mask_ds = None
if (self.maskband > 0):
mask_ds = driver.Create('/vsimem/alpha', width, height, src_ds.RasterCount, gdal.GDT_Float32)
if (mask_ds is None):
raise Exception('Failed to create dataset mask.')
[mask_ds.GetRasterBand(i).SetNoDataValue(float('nan')) for i in xrange(1, (src_ds.RasterCount + 1))]
merc = osr.SpatialReference()
merc.ImportFromProj4(srs)
area_ds.SetProjection(merc.ExportToWkt())
if (mask_ds is not None):
mask_ds.SetProjection(merc.ExportToWkt())
(x, y) = (xmin, ymax)
(w, h) = ((xmax - xmin), (ymin - ymax))
gtx = [x, (w / width), 0, y, 0, (h / height)]
area_ds.SetGeoTransform(gtx)
if (mask_ds is not None):
mask_ds.SetGeoTransform(gtx)
resample = self.resample
if (resample == gdal.GRA_CubicSpline):
xscale = (area_ds.GetGeoTransform()[1] / src_ds.GetGeoTransform()[1])
yscale = (area_ds.GetGeoTransform()[5] / src_ds.GetGeoTransform()[5])
diff = max(abs((xscale - 1)), abs((yscale - 1)))
if (diff < 0.001):
resample = gdal.GRA_Cubic
src_sref = osr.SpatialReference()
src_sref.ImportFromWkt(src_ds.GetProjection())
gdal.ReprojectImage(src_ds, area_ds, src_ds.GetProjection(), area_ds.GetProjection(), resample)
if (mask_ds is not None):
gdal.ReprojectImage(src_ds, mask_ds, src_ds.GetProjection(), mask_ds.GetProjection(), gdal.GRA_NearestNeighbour)
channel = ((grayscale_src and (1, 1, 1)) or (1, 2, 3))
(r, g, b) = [area_ds.GetRasterBand(i).ReadRaster(0, 0, width, height) for i in channel]
if (mask_ds is None):
data = ''.join([''.join(pixel) for pixel in zip(r, g, b)])
area = Image.frombytes('RGB', (width, height), data)
else:
a = mask_ds.GetRasterBand(self.maskband).GetMaskBand().ReadRaster(0, 0, width, height)
data = ''.join([''.join(pixel) for pixel in zip(r, g, b, a)])
area = Image.frombytes('RGBA', (width, height), data)
finally:
driver.Delete('/vsimem/output')
if (self.maskband > 0):
driver.Delete('/vsimem/alpha')
return area
|
'Get mime-type and format by file extension.
This only accepts "json".'
| def getTypeByExtension(self, extension):
| if (extension.lower() != 'json'):
raise KnownUnknown(('UtfGridComposite only makes .json tiles, not "%s"' % extension))
return ('text/json', 'JSON')
|
'Initialize Cascadenik provider with layer and mapfile.'
| def __init__(self, layer, mapfile, fonts=None, workdir=None):
| self.workdir = (workdir or gettempdir())
self.mapnik = None
ImageProvider.__init__(self, layer, mapfile, fonts)
|
'Mostly hand off functionality to Mapnik.ImageProvider.renderArea()'
| def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
| if (self.mapnik is None):
self.mapnik = mapnik.Map(0, 0)
load_map(self.mapnik, str(self.mapfile), self.workdir, cache_dir=self.workdir)
return ImageProvider.renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom)
|
''
| def renderArea(self, width_, height_, srs, xmin_, ymin_, xmax_, ymax_, zoom):
| merc = Proj(srs)
(lon, lat) = merc(((xmin_ + xmax_) / 2), ((ymin_ + ymax_) / 2), inverse=True)
zone = lon2zone(lon)
hemi = lat2hemi(lat)
utm = Proj(proj='utm', zone=zone, datum='WGS84')
((minlon, minlat), (maxlon, maxlat)) = (merc(xmin_, ymin_, inverse=1), merc(xmax_, ymax_, inverse=1))
((xmin, ymin), (xmax, ymax)) = (utm(minlon, minlat), utm(maxlon, maxlat))
pixels = _hypot(width_, height_)
units = _hypot((xmax - xmin), (ymax - ymin))
tick = ((self.tick * units) / pixels)
count = (pixels / self.spacing)
bound = (units / count)
zeros = int(_ceil((_log(bound) / _log(10))))
step = int(_pow(10, zeros))
(xbot, xtop) = (int((xmin - (xmin % step))), (int((xmax - (xmax % step))) + (2 * step)))
(ybot, ytop) = (int((ymin - (ymin % step))), (int((ymax - (xmax % step))) + (2 * step)))
img = Image.new('RGBA', (width_, height_), (238, 238, 238, 0))
draw = ImageDraw.ImageDraw(img)
xform = transform(width_, height_, xmin_, ymax_, xmax_, ymin_)
lines = []
labels = []
for col in range(xbot, xtop, step):
utms = [(col, y) for y in range(ybot, ytop, (step / 10))]
mercs = [merc(*utm(x, y, inverse=1)) for (x, y) in utms]
lines.append([xform(x, y) for (x, y) in mercs])
for row in range(ybot, ytop, (step / 10)):
mercs = [merc(*utm(x, y, inverse=1)) for (x, y) in ((col, row), ((col - tick), row))]
lines.append([xform(x, y) for (x, y) in mercs])
for row in range(ybot, ytop, step):
utms = [(x, row) for x in range(xbot, xtop, (step / 10))]
mercs = [merc(*utm(x, y, inverse=1)) for (x, y) in utms]
lines.append([xform(x, y) for (x, y) in mercs])
for col in range(xbot, xtop, (step / 10)):
mercs = [merc(*utm(x, y, inverse=1)) for (x, y) in ((col, row), (col, (row - tick)))]
lines.append([xform(x, y) for (x, y) in mercs])
for x in range(xbot, xtop, step):
for y in range(ybot, ytop, step):
(lon, lat) = utm(x, y, inverse=1)
grid = lonlat2grid(lon, lat)
point = xform(*merc(lon, lat))
if (self.display == 'utm'):
e = ('%07d' % x)[:(- zeros)]
n = ('%07d' % y)[:(- zeros)]
text = ' '.join([grid, e, n])
elif (self.display == 'mgrs'):
(e, n) = Proj(proj='utm', zone=lon2zone(lon), datum='WGS84')(lon, lat)
text = utm2mgrs(round(e), round(n), grid, zeros)
labels.append((point, text))
for ((x, y), text) in labels:
(x, y) = ((x + 2), (y - 18))
(w, h) = self.font.getsize(text)
draw.rectangle(((x - 2), y, ((x + w) + 2), (y + h)), fill=(255, 255, 255, 153))
for line in lines:
draw.line(line, fill=(255, 255, 255))
for line in lines:
draw.line([((x - 1), (y - 1)) for (x, y) in line], fill=(0, 0, 0))
for ((x, y), text) in labels:
(x, y) = ((x + 2), (y - 18))
draw.text((x, y), text, fill=(0, 0, 0), font=self.font)
return img
|
'Initialize the Monkeycache Provider.
Cache_config is a complete cache configuration dictionary that you
might use in a TileStache setup (http://tilestache.org/doc/#caches).
This is where Monkeycache will look for already-rendered tiles.
Layer_name is the name of a layer saved in that cache.
Format should match the second return value of your original
layer\'s getTypeByExtention() method, e.g. "PNG", "JPEG", or for
the Vector provider "GeoJSON" and others. This might not necessarily
match the file name extension, though common cases like "jpg"/"JPEG"
are accounted for.'
| def __init__(self, layer, cache_config, layer_name, format='PNG'):
| fake_layer_dict = {'provider': {'name': 'Proxy', 'url': 'http://localhost/{Z}/{X}/{Y}.png'}}
fake_config_dict = {'cache': cache_config, 'layers': {layer_name: fake_layer_dict}}
fake_config = buildConfiguration(fake_config_dict, layer.config.dirpath)
self.source_layer = fake_config.layers[layer_name]
self.source_cache = fake_config.cache
formats = dict(png='PNG', jpg='JPEG', jpeg='JPEG')
self.tile_format = formats.get(format.lower(), format)
|
'Pull a single tile from self.source_cache.'
| def renderTile(self, width, height, srs, coord):
| body = self.source_cache.read(self.source_layer, coord, self.tile_format)
return ResponseWrapper(body, self.tile_format)
|
''
| def __init__(self, config, redis_host='localhost', redis_port=6379):
| TileStache.WSGITileServer.__init__(self, config)
self.redis_kwargs = dict(host=redis_host, port=redis_port)
self.config.cache = CacheWrap(self.config.cache, self.redis_kwargs)
update_status('Created', **self.redis_kwargs)
|
''
| def __call__(self, environ, start_response):
| start = time()
if (environ['PATH_INFO'] == '/status'):
start_response('200 OK', [('Content-Type', 'text/plain')])
return status_response(**self.redis_kwargs)
if (environ['PATH_INFO'] == '/favicon.ico'):
start_response('404 Not Found', [('Content-Type', 'text/plain')])
return ''
try:
update_status(('Started %s' % environ['PATH_INFO']), **self.redis_kwargs)
response = TileStache.WSGITileServer.__call__(self, environ, start_response)
update_status(('Finished %s in %.3f seconds' % (environ['PATH_INFO'], (time() - start))), **self.redis_kwargs)
return response
except Exception as e:
update_status(('Error: %s after %.3f seconds' % (str(e), (time() - start))), **self.redis_kwargs)
raise
|
''
| def __del__(self):
| update_status('Destroyed', **self.redis_kwargs)
|
'Acquire a cache lock for this tile.
Returns nothing, but blocks until the lock has been acquired.'
| def lock(self, layer, coord, format):
| mem = Client(self.servers)
key = tile_key(layer, coord, format, self.revision, self.key_prefix)
due = (_time() + layer.stale_lock_timeout)
try:
while (_time() < due):
if mem.add((key + '-lock'), 'locked.', layer.stale_lock_timeout):
return
_sleep(0.2)
mem.set((key + '-lock'), 'locked.', layer.stale_lock_timeout)
return
finally:
mem.disconnect_all()
|
'Release a cache lock for this tile.'
| def unlock(self, layer, coord, format):
| mem = Client(self.servers)
key = tile_key(layer, coord, format, self.revision, self.key_prefix)
mem.delete((key + '-lock'))
mem.disconnect_all()
|
'Remove a cached tile.'
| def remove(self, layer, coord, format):
| mem = Client(self.servers)
key = tile_key(layer, coord, format, self.revision, self.key_prefix)
mem.delete(key)
mem.disconnect_all()
|
'Read a cached tile.'
| def read(self, layer, coord, format):
| mem = Client(self.servers)
key = tile_key(layer, coord, format, self.revision, self.key_prefix)
value = mem.get(key)
mem.disconnect_all()
if (value is None):
return None
return b64decode(value.encode('ascii'))
|
'Save a cached tile.'
| def save(self, body, layer, coord, format):
| mem = Client(self.servers)
key = tile_key(layer, coord, format, self.revision, self.key_prefix)
if (body is not None):
body = b64encode(body).decode('ascii')
mem.set(key, body, (layer.cache_lifespan or 0))
mem.disconnect_all()
|
'Two required Coordinate objects defining tile pyramid bounds.
Boundaries are inclusive: upper_left_high is the left-most column,
upper-most row, and highest zoom level; lower_right_low is the
right-most column, furthest-dwn row, and lowest zoom level.'
| def __init__(self, upper_left_high, lower_right_low):
| self.upper_left_high = upper_left_high
self.lower_right_low = lower_right_low
|
'Check a tile Coordinate against the bounds, return true/false.'
| def excludes(self, tile):
| if (tile.zoom > self.upper_left_high.zoom):
return True
if (tile.zoom < self.lower_right_low.zoom):
return True
_tile = tile.zoomTo(self.lower_right_low.zoom)
if (_tile.column > self.lower_right_low.column):
return True
if (_tile.row > self.lower_right_low.row):
return True
__tile = tile.right().down().zoomTo(self.upper_left_high.zoom)
if (__tile.column < self.upper_left_high.column):
return True
if (__tile.row < self.upper_left_high.row):
return True
return False
|
'Single argument is a list of Bounds objects.'
| def __init__(self, bounds):
| self.bounds = bounds
|
'Check a tile Coordinate against the bounds, return false if none match.'
| def excludes(self, tile):
| for bound in self.bounds:
if (not bound.excludes(tile)):
return False
return True
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| return {'stack': config_dict['stack']}
|
'Render this image stack.
Given a coordinate, return an output image with the results of all the
layers in this stack pasted on in turn.
Final argument is a dictionary used to temporarily cache results
of layers retrieved from layer_bitmap(), to speed things up in case
of repeatedly-used identical images.'
| def draw_stack(self, coord, tiles):
| rendered = Blit.Color(0, 0, 0, 0)
for layer in self.stack:
if (('zoom' in layer) and (not in_zoom(coord, layer['zoom']))):
continue
(source_name, mask_name, color_name) = [layer.get(k, None) for k in ('src', 'mask', 'color')]
if (source_name and color_name and mask_name):
raise Core.KnownUnknown(("You can't specify src, color and mask together in a Sandwich Layer: %s, %s, %s" % (repr(source_name), repr(color_name), repr(mask_name))))
if (source_name and (source_name not in tiles)):
if (source_name in self.config.layers):
tiles[source_name] = layer_bitmap(self.config.layers[source_name], coord)
else:
tiles[source_name] = local_bitmap(source_name, self.config, coord, self.layer.dim)
if (mask_name and (mask_name not in tiles)):
tiles[mask_name] = layer_bitmap(self.config.layers[mask_name], coord)
if (source_name and color_name):
foreground = make_color(color_name).blend(tiles[source_name])
elif source_name:
foreground = tiles[source_name]
elif color_name:
foreground = make_color(color_name)
elif mask_name:
raise Core.KnownUnknown(('You have to provide more than just a mask to Sandwich Layer: %s' % repr(mask_name)))
else:
raise Core.KnownUnknown('You have to provide at least some combination of src, color and mask to Sandwich Layer')
for (name, args) in layer.get('adjustments', []):
adjustfunc = adjustment_names.get(name)(*args)
foreground = foreground.adjust(adjustfunc)
opacity = float(layer.get('opacity', 1.0))
blendfunc = blend_modes.get(layer.get('mode', None), None)
if mask_name:
rendered = rendered.blend(foreground, tiles[mask_name], opacity, blendfunc)
else:
rendered = rendered.blend(foreground, None, opacity, blendfunc)
return rendered
|
'Initialize a callable WSGI instance.
Config parameter can be a file path string for a JSON configuration
file or a configuration object with \'cache\', \'layers\', and
\'dirpath\' properties.
Optional autoreload boolean parameter causes config to be re-read
on each request, applicable only when config is a JSON file.'
| def __init__(self, config, autoreload=False):
| if (type(config) in (str, unicode, dict)):
self.autoreload = autoreload
self.config_path = config
try:
self.config = parseConfig(config)
except:
print('Error loading Tilestache config:')
raise
else:
assert hasattr(config, 'cache'), 'Configuration object must have a cache.'
assert hasattr(config, 'layers'), 'Configuration object must have layers.'
assert hasattr(config, 'dirpath'), 'Configuration object must have a dirpath.'
self.autoreload = False
self.config_path = None
self.config = config
|
''
| def __call__(self, environ, start_response):
| if self.autoreload:
try:
self.config = parseConfig(self.config_path)
except Exception as e:
raise Core.KnownUnknown(('Error loading Tilestache config file:\n%s' % str(e)))
try:
(layer, coord, ext) = splitPathInfo(environ['PATH_INFO'])
except Core.KnownUnknown as e:
return self._response(start_response, 400, str(e))
if (layer and (layer not in self.config.layers)):
return self._response(start_response, 404)
path_info = environ.get('PATH_INFO', None)
query_string = environ.get('QUERY_STRING', None)
script_name = environ.get('SCRIPT_NAME', None)
(status_code, headers, content) = requestHandler2(self.config, path_info, query_string, script_name)
return self._response(start_response, status_code, str(content), headers)
|
''
| def _response(self, start_response, code, content='', headers=None):
| headers = (headers or Headers([]))
if content:
headers.setdefault('Content-Length', str(len(content)))
start_response(('%d %s' % (code, httplib.responses[code])), headers.items())
return [content]
|
'Convert from Coordinate object to a Point object in EPSG:900913'
| def coordinateProj(self, coord):
| diameter = ((2 * _pi) * 6378137)
zoom = (_log(diameter) / _log(2))
coord = coord.zoomTo(zoom)
point = Point(coord.column, coord.row)
point.x = (point.x - (diameter / 2))
point.y = ((diameter / 2) - point.y)
return point
|
'Convert from Point object in EPSG:900913 to a Coordinate object'
| def projCoordinate(self, point):
| diameter = ((2 * _pi) * 6378137)
zoom = (_log(diameter) / _log(2))
coord = Coordinate(point.y, point.x, zoom)
coord.column = (coord.column + (diameter / 2))
coord.row = ((diameter / 2) - coord.row)
return coord
|
'Convert from Location object to a Point object in EPSG:900913'
| def locationProj(self, location):
| return self.coordinateProj(self.locationCoordinate(location))
|
'Convert from Point object in EPSG:900913 to a Location object'
| def projLocation(self, point):
| return self.coordinateLocation(self.projCoordinate(point))
|
'Convert from Coordinate object to a Point object in EPSG:4326'
| def coordinateProj(self, coord):
| return self.locationProj(self.coordinateLocation(coord))
|
'Convert from Point object in EPSG:4326 to a Coordinate object'
| def projCoordinate(self, point):
| return self.locationCoordinate(self.projLocation(point))
|
'Convert from Location object to a Point object in EPSG:4326'
| def locationProj(self, location):
| return Point(location.lon, location.lat)
|
'Convert from Point object in EPSG:4326 to a Location object'
| def projLocation(self, point):
| return Location(point.y, point.x)
|
''
| def _description(self, layer, coord, format):
| name = layer.name()
tile = ('%(zoom)d/%(column)d/%(row)d' % coord.__dict__)
return ' '.join((name, tile, format))
|
'Pretend to acquire a cache lock for this tile.'
| def lock(self, layer, coord, format):
| name = self._description(layer, coord, format)
if self.logfunc:
self.logfunc(('Test cache lock: ' + name))
|
'Pretend to release a cache lock for this tile.'
| def unlock(self, layer, coord, format):
| name = self._description(layer, coord, format)
if self.logfunc:
self.logfunc(('Test cache unlock: ' + name))
|
'Pretend to remove a cached tile.'
| def remove(self, layer, coord, format):
| name = self._description(layer, coord, format)
if self.logfunc:
self.logfunc(('Test cache remove: ' + name))
|
'Pretend to read a cached tile.'
| def read(self, layer, coord, format):
| name = self._description(layer, coord, format)
if self.logfunc:
self.logfunc(('Test cache read: ' + name))
return None
|
'Pretend to save a cached tile.'
| def save(self, body, layer, coord, format):
| name = self._description(layer, coord, format)
if self.logfunc:
self.logfunc(('Test cache save: %d bytes to %s' % (len(body), name)))
|
''
| def _filepath(self, layer, coord, format):
| l = layer.name()
z = ('%d' % coord.zoom)
e = format.lower()
e += ((self._is_compressed(format) and '.gz') or '')
if (self.dirs == 'safe'):
x = ('%06d' % coord.column)
y = ('%06d' % coord.row)
(x1, x2) = (x[:3], x[3:])
(y1, y2) = (y[:3], y[3:])
filepath = os.sep.join((l, z, x1, x2, y1, ((y2 + '.') + e)))
elif (self.dirs == 'portable'):
x = ('%d' % coord.column)
y = ('%d' % coord.row)
filepath = os.sep.join((l, z, x, ((y + '.') + e)))
elif (self.dirs == 'quadtile'):
(pad, length) = ((1 << 31), (1 + coord.zoom))
xs = bin((pad + int(coord.column)))[(- length):]
ys = bin((pad + int(coord.row)))[(- length):]
dirpath = ''.join([str(int((y + x), 2)) for (x, y) in zip(xs, ys)])
parts = [dirpath[i:(i + 3)] for i in range(0, len(dirpath), 3)]
filepath = os.sep.join((([l] + parts[:(-1)]) + [((parts[(-1)] + '.') + e)]))
else:
raise KnownUnknown(('Please provide a valid "dirs" parameter to the Disk cache, either "safe", "portable" or "quadtile" but not "%s"' % self.dirs))
return filepath
|
''
| def _fullpath(self, layer, coord, format):
| filepath = self._filepath(layer, coord, format)
fullpath = pathjoin(self.cachepath, filepath)
return fullpath
|
''
| def _lockpath(self, layer, coord, format):
| return (self._fullpath(layer, coord, format) + '.lock')
|
'Acquire a cache lock for this tile.
Returns nothing, but blocks until the lock has been acquired.
Lock is implemented as an empty directory next to the tile file.'
| def lock(self, layer, coord, format):
| lockpath = self._lockpath(layer, coord, format)
due = (time.time() + layer.stale_lock_timeout)
while True:
try:
umask_old = os.umask(self.umask)
if (time.time() > due):
try:
os.rmdir(lockpath)
except OSError:
pass
os.makedirs(lockpath, (511 & (~ self.umask)))
break
except OSError as e:
if (e.errno != 17):
raise
time.sleep(0.2)
finally:
os.umask(umask_old)
|
'Release a cache lock for this tile.
Lock is implemented as an empty directory next to the tile file.'
| def unlock(self, layer, coord, format):
| lockpath = self._lockpath(layer, coord, format)
try:
os.rmdir(lockpath)
except OSError:
pass
|
'Remove a cached tile.'
| def remove(self, layer, coord, format):
| fullpath = self._fullpath(layer, coord, format)
try:
os.remove(fullpath)
except OSError as e:
if (e.errno != 2):
raise
|
'Read a cached tile.'
| def read(self, layer, coord, format):
| fullpath = self._fullpath(layer, coord, format)
if (not exists(fullpath)):
return None
age = (time.time() - os.stat(fullpath).st_mtime)
if (layer.cache_lifespan and (age > layer.cache_lifespan)):
return None
elif self._is_compressed(format):
return gzip.open(fullpath, 'r').read()
else:
body = open(fullpath, 'rb').read()
return body
|
'Save a cached tile.'
| def save(self, body, layer, coord, format):
| fullpath = self._fullpath(layer, coord, format)
try:
umask_old = os.umask(self.umask)
os.makedirs(dirname(fullpath), (511 & (~ self.umask)))
except OSError as e:
if (e.errno != 17):
raise
finally:
os.umask(umask_old)
suffix = ('.' + format.lower())
suffix += ((self._is_compressed(format) and '.gz') or '')
(fh, tmp_path) = mkstemp(dir=self.cachepath, suffix=suffix)
if self._is_compressed(format):
os.close(fh)
tmp_file = gzip.open(tmp_path, 'w')
tmp_file.write(body)
tmp_file.close()
else:
os.write(fh, body)
os.close(fh)
try:
os.rename(tmp_path, fullpath)
except OSError:
os.unlink(fullpath)
os.rename(tmp_path, fullpath)
os.chmod(fullpath, (438 & (~ self.umask)))
|
'Acquire a cache lock for this tile in the first tier.
Returns nothing, but blocks until the lock has been acquired.'
| def lock(self, layer, coord, format):
| return self.tiers[0].lock(layer, coord, format)
|
'Release a cache lock for this tile in the first tier.'
| def unlock(self, layer, coord, format):
| return self.tiers[0].unlock(layer, coord, format)
|
'Remove a cached tile from every tier.'
| def remove(self, layer, coord, format):
| for (index, cache) in enumerate(self.tiers):
cache.remove(layer, coord, format)
|
'Read a cached tile.
Start at the first tier and work forwards until a cached tile
is found. When found, save it back to the earlier tiers for faster
access on future requests.'
| def read(self, layer, coord, format):
| for (index, cache) in enumerate(self.tiers):
body = cache.read(layer, coord, format)
if body:
for cache in self.tiers[:index]:
cache.save(body, layer, coord, format)
return body
return None
|
'Save a cached tile.
Every tier gets a saved copy.'
| def save(self, body, layer, coord, format):
| for (index, cache) in enumerate(self.tiers):
cache.save(body, layer, coord, format)
|
'Acquire a cache lock for this tile.
Returns nothing, but blocks until the lock has been acquired.
Does nothing and returns immediately if `use_locks` is false.'
| def lock(self, layer, coord, format):
| if (not self.use_locks):
return
key_name = tile_key(layer, coord, format, self.path)
due = (_time() + layer.stale_lock_timeout)
while (_time() < due):
if (not self.bucket.get_key((key_name + '-lock'))):
break
_sleep(0.2)
key = self.bucket.new_key((key_name + '-lock'))
key.set_contents_from_string('locked.', {'Content-Type': 'text/plain'}, reduced_redundancy=self.reduced_redundancy)
|
'Release a cache lock for this tile.'
| def unlock(self, layer, coord, format):
| if (not self.use_locks):
return
key_name = tile_key(layer, coord, format, self.path)
self.bucket.delete_key((key_name + '-lock'))
|
'Remove a cached tile.'
| def remove(self, layer, coord, format):
| key_name = tile_key(layer, coord, format, self.path)
self.bucket.delete_key(key_name)
|
'Read a cached tile.'
| def read(self, layer, coord, format):
| key_name = tile_key(layer, coord, format, self.path)
key = self.bucket.get_key(key_name)
if (key is None):
return None
if layer.cache_lifespan:
t = timegm(strptime(key.last_modified, '%a, %d %b %Y %H:%M:%S %Z'))
if ((time() - t) > layer.cache_lifespan):
return None
return key.get_contents_as_string()
|
'Save a cached tile.'
| def save(self, body, layer, coord, format):
| key_name = tile_key(layer, coord, format, self.path)
key = self.bucket.new_key(key_name)
(content_type, encoding) = guess_type(('example.' + format))
headers = ((content_type and {'Content-Type': content_type}) or {})
key.set_contents_from_string(body, headers, policy=self.policy, reduced_redundancy=self.reduced_redundancy)
|
''
| def save(self, out, format):
| if (format == 'WKT'):
if ('wkt' in self.content['crs']):
out.write(self.content['crs']['wkt'])
else:
out.write(_sref_4326().ExportToWkt())
return
if (format in ('GeoJSON', 'GeoBSON', 'GeoAMF')):
content = self.content
if ('wkt' in content['crs']):
content['crs'] = {'type': 'link', 'properties': {'href': '0.wkt', 'type': 'ogcwkt'}}
else:
del content['crs']
elif (format in ('ArcJSON', 'ArcBSON', 'ArcAMF')):
content = reserialize_to_arc(self.content, (format == 'ArcAMF'))
else:
raise KnownUnknown(('Vector response only saves .geojson, .arcjson, .geobson, .arcbson, .geoamf, .arcamf and .wkt tiles, not "%s"' % format))
if (format in ('GeoJSON', 'ArcJSON')):
indent = ((self.verbose and 2) or None)
encoded = JSONEncoder(indent=indent).iterencode(content)
float_pat = compile('^-?\\d+\\.\\d+$')
for atom in encoded:
if float_pat.match(atom):
piece = (('%%.%if' % self.precision) % float(atom))
else:
piece = atom
out.write(piece.encode('utf8'))
elif (format in ('GeoBSON', 'ArcBSON')):
import bson
encoded = bson.dumps(content)
out.write(encoded)
elif (format in ('GeoAMF', 'ArcAMF')):
import pyamf
for class_name in pyamf_classes.items():
pyamf.register_class(*class_name)
encoded = pyamf.encode(content, 0).read()
out.write(encoded)
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| kwargs = dict()
kwargs['driver'] = config_dict['driver']
kwargs['parameters'] = config_dict['parameters']
kwargs['id_property'] = config_dict.get('id_property', None)
kwargs['properties'] = config_dict.get('properties', None)
kwargs['projected'] = bool(config_dict.get('projected', False))
kwargs['verbose'] = bool(config_dict.get('verbose', False))
kwargs['precision'] = int(config_dict.get('precision', 6))
kwargs['skip_empty_fields'] = bool(config_dict.get('skip_empty_fields', False))
if ('spacing' in config_dict):
kwargs['spacing'] = float(config_dict.get('spacing', 0.0))
else:
kwargs['spacing'] = None
if (config_dict.get('clipped', None) == 'padded'):
kwargs['clipped'] = 'padded'
else:
kwargs['clipped'] = bool(config_dict.get('clipped', True))
return kwargs
|
'Render a single tile, return a VectorResponse instance.'
| def renderTile(self, width, height, srs, coord):
| (layer, ds) = _open_layer(self.driver, self.parameters, self.layer.config.dirpath)
features = _get_features(coord, self.properties, self.layer.projection, layer, self.clipped, self.projected, self.spacing, self.id_property, self.skip_empty_fields)
response = {'type': 'FeatureCollection', 'features': features}
if self.projected:
sref = osr.SpatialReference()
sref.ImportFromProj4(self.layer.projection.srs)
response['crs'] = {'wkt': sref.ExportToWkt()}
if (srs == getProjectionByName('spherical mercator').srs):
response['crs']['wkid'] = 102113
else:
response['crs'] = {'srid': 4326, 'wkid': 4326}
return VectorResponse(response, self.verbose, self.precision)
|
'Get mime-type and format by file extension.
This only accepts "geojson" for the time being.'
| def getTypeByExtension(self, extension):
| if (extension.lower() == 'geojson'):
return ('application/json', 'GeoJSON')
elif (extension.lower() == 'arcjson'):
return ('application/json', 'ArcJSON')
elif (extension.lower() == 'geobson'):
return ('application/x-bson', 'GeoBSON')
elif (extension.lower() == 'arcbson'):
return ('application/x-bson', 'ArcBSON')
elif (extension.lower() == 'geoamf'):
return ('application/x-amf', 'GeoAMF')
elif (extension.lower() == 'arcamf'):
return ('application/x-amf', 'ArcAMF')
elif (extension.lower() == 'wkt'):
return ('text/x-wkt', 'WKT')
raise KnownUnknown(('Vector Provider only makes .geojson, .arcjson, .geobson, .arcbson, .geoamf, .arcamf and .wkt tiles, not "%s"' % extension))
|
'Initialize Mapnik provider with layer and mapfile.
XML mapfile keyword arg comes from TileStache config,
and is an absolute path by the time it gets here.'
| def __init__(self, layer, mapfile, fonts=None, scale_factor=None):
| maphref = urljoin(layer.config.dirpath, mapfile)
(scheme, h, path, q, p, f) = urlparse(maphref)
if (scheme in ('file', '')):
self.mapfile = path
else:
self.mapfile = maphref
self.layer = layer
self.mapnik = None
engine = mapnik.FontEngine.instance()
if fonts:
fontshref = urljoin(layer.config.dirpath, fonts)
(scheme, h, path, q, p, f) = urlparse(fontshref)
if (scheme not in ('file', '')):
raise Exception(('Fonts from "%s" can\'t be used by Mapnik' % fontshref))
for font in glob((path.rstrip('/') + '/*.ttf')):
engine.register_font(str(font))
self.scale_factor = scale_factor
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| kwargs = {'mapfile': config_dict['mapfile']}
if ('fonts' in config_dict):
kwargs['fonts'] = config_dict['fonts']
if ('scale factor' in config_dict):
kwargs['scale_factor'] = int(config_dict['scale factor'])
return kwargs
|
''
| def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
| start_time = time()
if global_mapnik_lock.acquire():
try:
if (self.mapnik is None):
self.mapnik = get_mapnikMap(self.mapfile)
logging.debug('TileStache.Mapnik.ImageProvider.renderArea() %.3f to load %s', (time() - start_time), self.mapfile)
self.mapnik.width = width
self.mapnik.height = height
self.mapnik.zoom_to_box(Box2d(xmin, ymin, xmax, ymax))
img = mapnik.Image(width, height)
if (self.scale_factor is None):
mapnik.render(self.mapnik, img)
else:
mapnik.render(self.mapnik, img, self.scale_factor)
except:
self.mapnik = None
raise
finally:
global_mapnik_lock.release()
if hasattr(Image, 'frombytes'):
img = Image.frombytes('RGBA', (width, height), img.tostring())
else:
img = Image.fromstring('RGBA', (width, height), img.tostring())
logging.debug('TileStache.Mapnik.ImageProvider.renderArea() %dx%d in %.3f from %s', width, height, (time() - start_time), self.mapfile)
return img
|
'Initialize Mapnik grid provider with layer and mapfile.
XML mapfile keyword arg comes from TileStache config,
and is an absolute path by the time it gets here.'
| def __init__(self, layer, mapfile, fields=None, layers=None, layer_index=0, scale=4, layer_id_key=None):
| self.mapnik = None
self.layer = layer
maphref = urljoin(layer.config.dirpath, mapfile)
(scheme, h, path, q, p, f) = urlparse(maphref)
if (scheme in ('file', '')):
self.mapfile = path
else:
self.mapfile = maphref
self.scale = scale
self.layer_id_key = layer_id_key
if layers:
self.layers = layers
else:
self.layers = [[(layer_index or 0), fields]]
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| kwargs = {'mapfile': config_dict['mapfile']}
for key in ('fields', 'layers', 'layer_index', 'scale', 'layer_id_key'):
if (key in config_dict):
kwargs[key] = config_dict[key]
return kwargs
|
''
| def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
| start_time = time()
if global_mapnik_lock.acquire():
try:
if (self.mapnik is None):
self.mapnik = get_mapnikMap(self.mapfile)
logging.debug('TileStache.Mapnik.GridProvider.renderArea() %.3f to load %s', (time() - start_time), self.mapfile)
self.mapnik.width = width
self.mapnik.height = height
self.mapnik.zoom_to_box(Box2d(xmin, ymin, xmax, ymax))
if (self.layer_id_key is not None):
grids = []
for (index, fields) in self.layers:
datasource = self.mapnik.layers[index].datasource
fields = (((type(fields) is list) and map(str, fields)) or datasource.fields())
grid = mapnik.Grid(width, height)
mapnik.render_layer(self.mapnik, grid, layer=index, fields=fields)
grid = grid.encode('utf', resolution=self.scale, features=True)
for key in grid['data']:
grid['data'][key][self.layer_id_key] = self.mapnik.layers[index].name
grids.append(grid)
outgrid = reduce(merge_grids, grids)
else:
grid = mapnik.Grid(width, height)
for (index, fields) in self.layers:
datasource = self.mapnik.layers[index].datasource
fields = (((type(fields) is list) and map(str, fields)) or datasource.fields())
mapnik.render_layer(self.mapnik, grid, layer=index, fields=fields)
outgrid = grid.encode('utf', resolution=self.scale, features=True)
except:
self.mapnik = None
raise
finally:
global_mapnik_lock.release()
logging.debug('TileStache.Mapnik.GridProvider.renderArea() %dx%d at %d in %.3f from %s', width, height, self.scale, (time() - start_time), self.mapfile)
return SaveableResponse(outgrid, self.scale)
|
'Get mime-type and format by file extension.
This only accepts "json".'
| def getTypeByExtension(self, extension):
| if (extension.lower() != 'json'):
raise KnownUnknown(('MapnikGrid only makes .json tiles, not "%s"' % extension))
return ('application/json; charset=utf-8', 'JSON')
|
'Return a cropped grid response.'
| def crop(self, bbox):
| (minchar, minrow, maxchar, maxrow) = [(v / self.scale) for v in bbox]
(keys, data) = (self.content['keys'], self.content.get('data', None))
grid = [row[minchar:maxchar] for row in self.content['grid'][minrow:maxrow]]
cropped = dict(keys=keys, data=data, grid=grid)
return SaveableResponse(cropped, self.scale)
|
'Return True if this is really a metatile with a buffer or multiple tiles.
A default 1x1 metatile with buffer=0 is not for real.'
| def isForReal(self):
| return ((self.buffer > 0) or (self.rows > 1) or (self.columns > 1))
|
'Return a new coordinate for the upper-left corner of a metatile.
This is useful as a predictable way to refer to an entire metatile
by one of its sub-tiles, currently needed to do locking correctly.'
| def firstCoord(self, coord):
| return self.allCoords(coord)[0]
|
'Return a list of coordinates for a complete metatile.
Results are guaranteed to be ordered left-to-right, top-to-bottom.'
| def allCoords(self, coord):
| (rows, columns) = (int(self.rows), int(self.columns))
row = (rows * (int(coord.row) / rows))
column = (columns * (int(coord.column) / columns))
coords = []
for r in range(rows):
for c in range(columns):
coords.append(Coordinate((row + r), (column + c), coord.zoom))
return coords
|
'Figure out what I\'m called, return a name if there is one.
Layer names are stored in the Configuration object, so
config.layers must be inspected to find a matching name.'
| def name(self):
| for (name, layer) in self.config.layers.items():
if (layer is self):
return name
return None
|
'Get status code, headers, and a tile binary for a given request layer tile.
Arguments:
- coord: one ModestMaps.Core.Coordinate corresponding to a single tile.
- extension: filename extension to choose response type, e.g. "png" or "jpg".
- ignore_cached: always re-render the tile, whether it\'s in the cache or not.
This is the main entry point, after site configuration has been loaded
and individual tiles need to be rendered.'
| def getTileResponse(self, coord, extension, ignore_cached=False):
| start_time = time()
(mimetype, format) = self.getTypeByExtension(extension)
status_code = 200
headers = Headers([('Content-Type', mimetype)])
body = None
cache = self.config.cache
if (not ignore_cached):
try:
body = cache.read(self, coord, format)
except TheTileLeftANote as e:
headers = e.headers
status_code = e.status_code
body = e.content
if e.emit_content_type:
headers.setdefault('Content-Type', mimetype)
tile_from = 'cache'
else:
body = _getRecentTile(self, coord, format)
tile_from = 'recent tiles'
if (body is None):
try:
lockCoord = None
if self.write_cache:
lockCoord = self.metatile.firstCoord(coord)
cache.lock(self, lockCoord, format)
if (not ignore_cached):
body = cache.read(self, coord, format)
tile_from = 'cache after all'
if (body is None):
buff = BytesIO()
try:
tile = self.render(coord, format)
save = True
except NoTileLeftBehind as e:
tile = e.tile
save = False
status_code = 404
if (not self.write_cache):
save = False
if (format.lower() == 'jpeg'):
save_kwargs = self.jpeg_options
elif (format.lower() == 'png'):
save_kwargs = self.png_options
else:
save_kwargs = {}
tile.save(buff, format, **save_kwargs)
body = buff.getvalue()
if save:
cache.save(body, self, coord, format)
tile_from = 'layer.render()'
except TheTileLeftANote as e:
headers = e.headers
status_code = e.status_code
body = e.content
if e.emit_content_type:
headers.setdefault('Content-Type', mimetype)
finally:
if lockCoord:
cache.unlock(self, lockCoord, format)
_addRecentTile(self, coord, format, body)
logging.info('TileStache.Core.Layer.getTileResponse() %s/%d/%d/%d.%s via %s in %.3f', self.name(), coord.zoom, coord.column, coord.row, extension, tile_from, (time() - start_time))
return (status_code, headers, body)
|
'Return True if we have a real metatile and the provider is OK with it.'
| def doMetatile(self):
| return (self.metatile.isForReal() and hasattr(self.provider, 'renderArea'))
|
'Render a tile for a coordinate, return PIL Image-like object.
Perform metatile slicing here as well, if required, writing the
full set of rendered tiles to cache as we go.
Note that metatiling and pass-through mode of a Provider
are mutually exclusive options'
| def render(self, coord, format):
| if (self.bounds and self.bounds.excludes(coord)):
raise NoTileLeftBehind(Image.new('RGBA', (self.dim, self.dim), (0, 0, 0, 0)))
srs = self.projection.srs
(xmin, ymin, xmax, ymax) = self.envelope(coord)
(width, height) = (self.dim, self.dim)
provider = self.provider
metatile = self.metatile
pass_through = (provider.pass_through if hasattr(provider, 'pass_through') else False)
if self.doMetatile():
if pass_through:
raise KnownUnknown('Your provider is configured for metatiling and pass_through mode. That does not work')
(xmin, ymin, xmax, ymax) = self.metaEnvelope(coord)
(width, height) = self.metaSize(coord)
subtiles = self.metaSubtiles(coord)
if (self.doMetatile() or hasattr(provider, 'renderArea')):
tile = provider.renderArea(width, height, srs, xmin, ymin, xmax, ymax, coord.zoom)
elif hasattr(provider, 'renderTile'):
(width, height) = (self.dim, self.dim)
tile = provider.renderTile(width, height, srs, coord)
else:
raise KnownUnknown('Your provider lacks renderTile and renderArea methods.')
if (not hasattr(tile, 'save')):
raise KnownUnknown('Return value of provider.renderArea() must act like an image; e.g. have a "save" method.')
if (hasattr(tile, 'size') and (tile.size[1] != height)):
raise KnownUnknown(('Your provider returned the wrong image size: %s instead of %d pixels tall.' % (repr(tile.size), self.dim)))
if self.bitmap_palette:
if pass_through:
raise KnownUnknown('Cannot apply palette in pass_through mode')
if (format.lower() == 'png'):
t_index = self.png_options.get('transparency', None)
tile = apply_palette(tile, self.bitmap_palette, t_index)
if self.pixel_effect:
if pass_through:
raise KnownUnknown('Cannot apply pixel effect in pass_through mode')
if (format.lower() in ('png', 'jpeg', 'tiff', 'bmp', 'gif')):
tile = self.pixel_effect.apply(tile)
if self.doMetatile():
(tile, surtile) = (None, tile)
for (other, x, y) in subtiles:
buff = BytesIO()
bbox = (x, y, (x + self.dim), (y + self.dim))
subtile = surtile.crop(bbox)
if self.palette256:
subtile = apply_palette256(subtile)
subtile.save(buff, format)
body = buff.getvalue()
if self.write_cache:
self.config.cache.save(body, self, other, format)
if (other == coord):
tile = subtile
_addRecentTile(self, other, format, body)
return tile
|
'Projected rendering envelope (xmin, ymin, xmax, ymax) for a Coordinate.'
| def envelope(self, coord):
| ul = self.projection.coordinateProj(coord)
lr = self.projection.coordinateProj(coord.down().right())
return (min(ul.x, lr.x), min(ul.y, lr.y), max(ul.x, lr.x), max(ul.y, lr.y))
|
'Projected rendering envelope (xmin, ymin, xmax, ymax) for a metatile.'
| def metaEnvelope(self, coord):
| buffer = (float(self.metatile.buffer) / self.dim)
coords = self.metatile.allCoords(coord)
ul = coords[0].left(buffer).up(buffer)
lr = coords[(-1)].right((1 + buffer)).down((1 + buffer))
ul = self.projection.coordinateProj(ul)
lr = self.projection.coordinateProj(lr)
return (min(ul.x, lr.x), min(ul.y, lr.y), max(ul.x, lr.x), max(ul.y, lr.y))
|
'Pixel width and height of full rendered image for a metatile.'
| def metaSize(self, coord):
| buffer = (float(self.metatile.buffer) / self.dim)
width = int((self.dim * ((buffer * 2) + self.metatile.columns)))
height = int((self.dim * ((buffer * 2) + self.metatile.rows)))
return (width, height)
|
'List of all coords in a metatile and their x, y offsets in a parent image.'
| def metaSubtiles(self, coord):
| subtiles = []
coords = self.metatile.allCoords(coord)
for other in coords:
r = (other.row - coords[0].row)
c = (other.column - coords[0].column)
x = ((c * self.dim) + self.metatile.buffer)
y = ((r * self.dim) + self.metatile.buffer)
subtiles.append((other, x, y))
return subtiles
|
'Get mime-type and PIL format by file extension.'
| def getTypeByExtension(self, extension):
| if hasattr(self.provider, 'getTypeByExtension'):
return self.provider.getTypeByExtension(extension)
elif (extension.lower() == 'png'):
return ('image/png', 'PNG')
elif (extension.lower() == 'jpg'):
return ('image/jpeg', 'JPEG')
else:
raise KnownUnknown(('Unknown extension in configuration: "%s"' % extension))
|
'Optional arguments are added to self.jpeg_options for pickup when saving.
More information about options:
http://effbot.org/imagingbook/format-jpeg.htm'
| def setSaveOptionsJPEG(self, quality=None, optimize=None, progressive=None):
| if (quality is not None):
self.jpeg_options['quality'] = int(quality)
if (optimize is not None):
self.jpeg_options['optimize'] = bool(optimize)
if (progressive is not None):
self.jpeg_options['progressive'] = bool(progressive)
|
'Optional arguments are added to self.png_options for pickup when saving.
Palette argument is a URL relative to the configuration file,
and it implies bits and optional transparency options.
More information about options:
http://effbot.org/imagingbook/format-png.htm'
| def setSaveOptionsPNG(self, optimize=None, palette=None, palette256=None):
| if (optimize is not None):
self.png_options['optimize'] = bool(optimize)
if (palette is not None):
palette = urljoin(self.config.dirpath, palette)
(palette, bits, t_index) = load_palette(palette)
(self.bitmap_palette, self.png_options['bits']) = (palette, bits)
if (t_index is not None):
self.png_options['transparency'] = t_index
if (palette256 is not None):
self.palette256 = bool(palette256)
else:
self.palette256 = None
|
'Return a guaranteed instance of PIL.Image.'
| def image(self):
| if (self._image is None):
self._image = Image.open(self.buffer)
return self._image
|
'Initialize Proxy provider with layer and url.'
| def __init__(self, layer, url=None, provider_name=None, timeout=None):
| if url:
self.provider = ModestMaps.Providers.TemplatedMercatorProvider(url)
elif provider_name:
if (provider_name in ModestMaps.builtinProviders):
self.provider = ModestMaps.builtinProviders[provider_name]()
else:
raise Exception(('Unkown Modest Maps provider: "%s"' % provider_name))
else:
raise Exception('Missing required url or provider parameter to Proxy provider')
self.timeout = timeout
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| kwargs = dict()
if ('url' in config_dict):
kwargs['url'] = config_dict['url']
if ('provider' in config_dict):
kwargs['provider_name'] = config_dict['provider']
if ('timeout' in config_dict):
kwargs['timeout'] = config_dict['timeout']
return kwargs
|
''
| def renderTile(self, width, height, srs, coord):
| img = None
urls = self.provider.getTileUrls(coord)
proxy_support = urllib2.ProxyHandler()
url_opener = urllib2.build_opener(proxy_support)
for url in urls:
body = url_opener.open(url, timeout=self.timeout).read()
tile = Verbatim(body)
if (len(urls) == 1):
return tile
elif (img is None):
img = Image.new('RGBA', (width, height))
img.paste(tile, (0, 0), tile)
return img
|
'Initialize a UrlTemplate provider with layer and template string.
http://docs.python.org/library/string.html#template-strings'
| def __init__(self, layer, template, referer=None, source_projection=None, timeout=None):
| self.layer = layer
self.template = Template(template)
self.referer = referer
self.source_projection = source_projection
self.timeout = timeout
|
'Convert configured parameters to keyword args for __init__().'
| @staticmethod
def prepareKeywordArgs(config_dict):
| kwargs = {'template': config_dict['template']}
if ('referer' in config_dict):
kwargs['referer'] = config_dict['referer']
if ('source projection' in config_dict):
kwargs['source_projection'] = Geography.getProjectionByName(config_dict['source projection'])
if ('timeout' in config_dict):
kwargs['timeout'] = config_dict['timeout']
return kwargs
|
'Return an image for an area.
Each argument (width, height, etc.) is substituted into the template.'
| def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):
| if (self.source_projection is not None):
ne_location = self.layer.projection.projLocation(Point(xmax, ymax))
ne_point = self.source_projection.locationProj(ne_location)
ymax = ne_point.y
xmax = ne_point.x
sw_location = self.layer.projection.projLocation(Point(xmin, ymin))
sw_point = self.source_projection.locationProj(sw_location)
ymin = sw_point.y
xmin = sw_point.x
srs = self.source_projection.srs
mapping = {'width': width, 'height': height, 'srs': srs, 'zoom': zoom, 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax}
href = self.template.safe_substitute(mapping)
req = urllib2.Request(href)
if self.referer:
req.add_header('Referer', self.referer)
body = urllib2.urlopen(req, timeout=self.timeout).read()
tile = Verbatim(body)
return tile
|
'Read configuration and verify successful read'
| def test_config(self):
| config_content = {'layers': {'memcache_osm': {'provider': {'name': 'proxy', 'url': 'http://tile.openstreetmap.org/{Z}/{X}/{Y}.png'}}}, 'cache': {'name': 'Memcache', 'servers': ['127.0.0.1:11211'], 'revision': 4}}
config = parseConfig(config_content)
self.assertEqual(config.cache.servers, ['127.0.0.1:11211'])
self.assertEqual(config.cache.revision, 4)
self.assertTrue(config.layers['memcache_osm'])
self.assertTrue(isinstance(config.layers['memcache_osm'], Core.Layer))
|
'Fetch tile from OSM using Proxy provider (web mercator)'
| def test_proxy_mercator(self):
| config_file_content = '\n {\n "layers":{\n "osm":{\n "provider":{\n "name":"proxy",\n "url": "http://tile.openstreetmap.org/{Z}/{X}/{Y}.png"\n }\n }\n },\n "cache": {\n "name": "Test"\n }\n }\n '
(tile_mimetype, tile_content) = utils.request(config_file_content, 'osm', 'png', 0, 0, 0)
self.assertEqual(tile_mimetype, 'image/png')
self.assertTrue((tile_content[:4] in '\x89PNG'))
|
'Fetch two WGS84 tiles from WMS using bbox'
| def test_url_template_wgs84(self):
| config_file_content = '\n {\n "layers":{\n "osgeo_wms":{\n "projection":"WGS84",\n "provider":{\n "name":"url template",\n "template":"http://vmap0.tiles.osgeo.org/wms/vmap0?LAYERS=basic&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&STYLES=&FORMAT=image%2Fpng&SRS=EPSG%3A4326&BBOX=$xmin,$ymin,$xmax,$ymax&WIDTH=256&HEIGHT=256"\n }\n }\n },\n "cache": {\n "name": "Test"\n }\n }\n '
(tile_mimetype, tile_content) = utils.request(config_file_content, 'osgeo_wms', 'png', 0, 0, 0)
self.assertEqual(tile_mimetype, 'image/png')
self.assertTrue((tile_content[:4] in '\x89PNG'))
(tile_mimetype, tile_content) = utils.request(config_file_content, 'osgeo_wms', 'png', 0, 1, 0)
self.assertEqual(tile_mimetype, 'image/png')
self.assertTrue((tile_content[:4] in '\x89PNG'))
|
'Fetch custom binary result using URL Template(result should not be modified)'
| def test_url_template_custom_binary(self):
| config_file_content = '\n {\n "layers":{\n "local_layer":{\n "projection":"WGS84",\n "provider":{\n "name":"url template",\n "template":"http://localhost:<<port>>/&BBOX=$xmin,$ymin,$xmax,$ymax"\n }\n }\n },\n "cache": {\n "name": "Test"\n }\n }\n '.replace('<<port>>', str(self.server_port))
(tile_mimetype, tile_content) = utils.request(config_file_content, 'local_layer', 'png', 0, 0, 0)
self.assertEquals(tile_mimetype, self.response_mimetype)
self.assertEquals(tile_content, self.response_content)
|
'Create 3 points (2 on west, 1 on east hemisphere) and retrieve as geojson.
2 points should be returned in western hemisphere and 1 on eastern at zoom level 0
(clip on)'
| def test_points_geojson(self):
| self.defineGeometry('POINT')
point_sf = Point((-122.4183), 37.775)
point_berlin = Point(13.4127, 52.5233)
point_lima = Point((-77.0283), 12.0433)
self.insertTestRow(point_sf.wkt, 'San Francisco')
self.insertTestRow(point_berlin.wkt, 'Berlin')
self.insertTestRow(point_lima.wkt, 'Lima')
(tile_mimetype, tile_content) = utils.request(self.config_file_content, 'vector_test', 'geojson', 0, 0, 0)
geojson_result = json.loads(tile_content.decode('utf8'))
self.assertTrue(tile_mimetype.endswith('/json'))
self.assertEqual(geojson_result['type'], 'FeatureCollection')
self.assertEqual(len(geojson_result['features']), 2)
cities = []
for feature in geojson_result['features']:
if (feature['properties']['name'] == 'San Francisco'):
cities.append(feature['properties']['name'])
self.assertTrue(point_sf.almost_equals(asShape(feature['geometry'])))
elif (feature['properties']['name'] == 'Lima'):
cities.append(feature['properties']['name'])
self.assertTrue(point_lima.almost_equals(asShape(feature['geometry'])))
self.assertTrue(('San Francisco' in cities))
self.assertTrue(('Lima' in cities))
(tile_mimetype, tile_content) = utils.request(self.config_file_content, 'vector_test', 'geojson', 0, 1, 0)
geojson_result = json.loads(tile_content.decode('utf8'))
self.assertTrue(tile_mimetype.endswith('/json'))
self.assertEqual(geojson_result['type'], 'FeatureCollection')
self.assertEqual(len(geojson_result['features']), 1)
self.assertTrue(('Berlin' in geojson_result['features'][0]['properties']['name']))
|
'Create a line that goes from west to east (clip on)'
| def test_linestring_geojson(self):
| self.defineGeometry('LINESTRING')
geom = LineString([((-180), 32), (180, 32)])
self.insertTestRow(geom.wkt)
(tile_mimetype, tile_content) = utils.request(self.config_file_content, 'vector_test', 'geojson', 0, 0, 0)
self.assertTrue(tile_mimetype.endswith('/json'))
geojson_result = json.loads(tile_content.decode('utf8'))
west_hemisphere_geometry = asShape(geojson_result['features'][0]['geometry'])
expected_geometry = LineString([((-180), 32), (0, 32)])
self.assertTrue(expected_geometry.almost_equals(west_hemisphere_geometry))
(tile_mimetype, tile_content) = utils.request(self.config_file_content, 'vector_test', 'geojson', 0, 1, 0)
self.assertTrue(tile_mimetype.endswith('/json'))
geojson_result = json.loads(tile_content.decode('utf8'))
east_hemisphere_geometry = asShape(geojson_result['features'][0]['geometry'])
expected_geometry = LineString([(0, 32), (180, 32)])
self.assertTrue(expected_geometry.almost_equals(east_hemisphere_geometry))
|
'Create a polygon to cover the world and make sure it is "similar" (clip on)'
| def test_polygon_geojson(self):
| self.defineGeometry('POLYGON')
geom = Polygon([((-180), (-90)), (180, (-90)), (180, 90), ((-180), 90), ((-180), (-90))])
self.insertTestRow(geom.wkt)
(tile_mimetype, tile_content) = utils.request(self.config_file_content, 'vector_test', 'geojson', 0, 0, 0)
self.assertTrue(tile_mimetype.endswith('/json'))
geojson_result = json.loads(tile_content.decode('utf8'))
result_geom = asShape(geojson_result['features'][0]['geometry'])
expected_geom = Polygon([((-180), (-90)), (0, (-90)), (0, 90), ((-180), 90), ((-180), (-90))])
self.assertTrue(result_geom.difference(expected_geom.buffer(0.001)).is_empty)
self.assertTrue(expected_geom.difference(result_geom.buffer(0.001)).is_empty)
|
'Fetch tile and check the existence in memcached'
| def test_memcache(self):
| config_file_content = '\n {\n "layers":{\n "memcache_osm":{\n "provider":{\n "name":"proxy",\n "url": "http://tile.openstreetmap.org/{Z}/{X}/{Y}.png"\n }\n }\n },\n "cache": {\n "name": "Memcache",\n "servers": ["127.0.0.1:11211"],\n "revision": 4\n }\n }\n '
(tile_mimetype, tile_content) = utils.request(config_file_content, 'memcache_osm', 'png', 0, 0, 0)
self.assertEqual(tile_mimetype, 'image/png')
memcache_content = b64decode(self.mc.get('/4/memcache_osm/0/0/0.PNG').encode('ascii'))
self.assertEqual(memcache_content, tile_content, 'Contents of memcached and value returned from TileStache should match')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.