def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a SaveableResponse instance.
"""
nw = self.layer.projection.coordinateLocation(coord)
se = self.layer.projection.coordinateLocation(coord.right().down())
ul = self.mercator.locationProj(nw)
lr = self.mercator.locationProj(se)
bbox = 'ST_SetSRID(ST_MakeBox2D(ST_MakePoint(%.6f, %.6f), ST_MakePoint(%.6f, %.6f)), 900913)' % (ul.x, ul.y, lr.x, lr.y)
clip = self.clipping and Polygon([(ul.x, ul.y), (lr.x, ul.y), (lr.x, lr.y), (ul.x, lr.y)]) or None
db = _connect(self.dbdsn).cursor(cursor_factory=RealDictCursor)
db.execute(self.query.replace('!bbox!', bbox))
rows = db.fetchall()
db.close()
response = {'type': 'FeatureCollection', 'features': []}
for row in rows:
feature = row2feature(row, self.id_field, self.geometry_field)
try:
geom = shape2geometry(feature['geometry'], self.mercator, clip)
except _InvisibleBike:
# don't output this geometry because it's empty
pass
else:
feature['geometry'] = geom
response['features'].append(feature)
return SaveableResponse(response, self.indent, self.precision)
def __init__(self, layer, type, query, **kwargs):
self.mercator = getProjectionByName('spherical mercator')
self.layer = layer
self.type = type
self. query = query
self.table = kwargs.get('table', 'planet_osm_line')
self.fill = kwargs.get('fill', '#000000')
self.zoom_factor = kwargs.get('zoom_factor', 2)
self.datasource = kwargs.get('datasource', 'xapi')
self.xapi = None
self.pgis = None
# Hey look! You're reading the source code and have found an
# Easter egg!! This is pretty much exactly what it looks like:
# Instead of querying the Mapquest XAPI endpoint you can also
# query a PostGIS database that has a copy of the rendering
# database (the thing that osm2pgsql creates). Please note that
# by querying a copy of the rendering database instead of a
# tagging database that the results returned may be incomplete
# and/or weird.
if self.datasource == 'postgis':
self.pgis = _connect(kwargs.get('dbdsn', '')).cursor(cursor_factory=RealDictCursor)
else:
self.xapi = mapquest.xapi.xapi()
def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a SaveableResponse instance.
"""
# tilesize = self.tileSize * 16
#
# # center pixel on zoomlevel
# center = (tilesize << coord.zoom) >> 1
# # maximum coordinate in web mercator
# f900913 = 20037508.342789244
#
# # pixel relative to global center
# dx = (coord.column * tilesize) - center
# # flip y-axis
# dy = center - (coord.row * tilesize)
#
# # size of one pixel
# div = f900913 / center
#
conn = _connect(self.dbdsn)
db = conn.cursor()
register_hstore(conn, True, False)
db.execute(self.query_tile, (coord.column * self.tileSize, coord.row * self.tileSize, coord.zoom))
rows = db.fetchall()
logging.debug(self.query_tile)
bbox = 0
tile = {"bbox": bbox, "granularity":10000, "features":[]}
features = []
for row in rows:
# empty geometry
if (row[0] is None) or (row[1] is None):
continue
#logging.debug(str(row[1]))
geojson = json.loads(str(row[1]))
# tags = {}
# for tag in row[0].iteritems():
# tags[tag[0]] = ("%s" %(tag[1])).decode('utf-8')
#
# print tags
#
# geojson["properties"] = tags
geojson["properties"] = row[0]
features.append(geojson)
tile["features"].extend(features)
try:
conn.commit()
except Exception, e:
logging.error(">>> %s", e)
conn.rollback()
def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a SaveableResponse instance.
"""
tilesize = 256 * 16
# center pixel on zoomlevel
center = (tilesize << coord.zoom) >> 1
# maximum coordinate in web mercator
f900913 = 20037508.342789244
# pixel relative to global center
dx = (coord.column * tilesize) - center
# flip y-axis
dy = center - (coord.row * tilesize)
# size of one pixel
div = f900913 / center
geomparser = WKBParser(dx, dy, div)
conn = _connect(self.dbdsn)
db = conn.cursor()
register_hstore(conn, True, False)
db.execute(self.query_tile, (coord.column, coord.row, coord.zoom))
rows = db.fetchall()
tile = TileData_pb2.Data()
tagdict = {}
for row in rows:
# empty geometry
if (row[0] is None) or (row[1] is None):
continue
self.addItem(tile, row, coord, geomparser, tagdict)
db.execute(self.query_tile_poi, (coord.column, coord.row, coord.zoom))
rows = db.fetchall()
for row in rows:
# empty geometry
if (row[0] is None) or (row[1] is None):
continue
self.addItem(tile, row, coord, geomparser, tagdict)
#db.close()
tile.num_tags = len(tile.keys)
try:
conn.commit()
except Exception, e:
logging.error(">>> %s", e)
conn.rollback()
def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a SaveableResponse instance.
"""
##return EmptyResponse(None, coord)
tile = VectorTile(self.extents)
conn = _connect(self.dbdsn)
db = conn.cursor()
register_hstore(conn, True, False)
try:
db.execute(self.query_tile, (coord.column, coord.row, coord.zoom))
except Exception, e:
logging.error("db: %s\n %s", coord, e)
raise KnownUnknown("query failed")
def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a ConfirmationResponse instance.
"""
if coord.zoom < 12:
raise KnownUnknown('MirrorOSM provider only handles data at zoom 12 or higher, not %d.' % coord.zoom)
start = time()
garbage = []
handle, filename = mkstemp(prefix='mirrorosm-', suffix='.tablename')
tmp_prefix = 'mirrorosm_' + b16encode(basename(filename)[10:-10]).lower()
garbage.append(filename)
close(handle)
handle, filename = mkstemp(prefix='mirrorosm-', suffix='.osm.gz')
garbage.append(filename)
close(handle)
try:
length = download_api_data(filename, coord, self.api_base, self.layer.projection)
prepare_data(filename, tmp_prefix, self.dbkwargs, self.osm2pgsql, self.layer.projection)
db = _connect(**self.dbkwargs).cursor()
ul = self.layer.projection.coordinateProj(coord)
lr = self.layer.projection.coordinateProj(coord.down().right())
create_tables(db, self.prefix, tmp_prefix)
populate_tables(db, self.prefix, tmp_prefix, (ul.x, ul.y, lr.x, lr.y))
clean_up_tables(db, tmp_prefix)
db.close()
message = 'Retrieved %dK of OpenStreetMap data for tile %d/%d/%d in %.2fsec from %s (%s).\n' \
% (length, coord.zoom, coord.column, coord.row,
(time() - start), self.api_base, datetime.now())
return ConfirmationResponse(coord, message, True)
except Exception as e:
message = 'Error in tile %d/%d/%d: %s' % (coord.zoom, coord.column, coord.row, e)
raise NoTileLeftBehind(ConfirmationResponse(coord, message, False))
finally:
for filename in garbage:
unlink(filename)
def connect(*keys, **kwargs):
conn = _connect(*keys, **kwargs)
if conn.server_version < 90200:
raise RuntimeError("Range types not available in version {version}".format(
conn.server_version))
# Register range types
register_range_caster(
"int4range", intrange, oid=3904, subtype_oid=23, array_oid=3905, scope=conn)
register_range_caster(
"int8range", intrange, oid=3926, subtype_oid=20, array_oid=3927, scope=conn)
register_range_caster(
"numrange", floatrange_preprocess, oid=3906, subtype_oid=1700, array_oid=3907, scope=conn)
register_range_caster(
"daterange", daterange, oid=3912, subtype_oid=1082, array_oid=3913, scope=conn)
register_range_caster(
"tsrange", datetimerange, oid=3908, subtype_oid=1114, array_oid=3909, scope=conn)
return conn
def __init__(self):
connection_url = "dbname=%s user=%s password=%s host=%s" % (
pg_config['dbname'], pg_config['user'], pg_config['passwd'],
pg_config['host'])
self.conn = psycopg2._connect(connection_url)
def __init__(self):
#DATABASE_URL = 'postgres://*****:*****@localhost:5432/jjkchat'
DATABASE_URL = "dbname=%s user=%s password=%s host=%s" % (
pg_config['dbname'], pg_config['user'], pg_config['passwd'],
pg_config['host'])
self.conn = psycopg2._connect(DATABASE_URL)
def __init__(self):
connection_url = "dbname=%s user=%s password=%s host = 'localhost'" % (
db_config['dbname'], db_config['user'], db_config['psswd'])
self.conn = psycopg2._connect(connection_url)
def __init__(self):
DATABASE_URL = 'postgres://*****:*****@ec2-54-225-96-191.compute-1.amazonaws.com:5432/dg5rkiotg2tr8'
self.conn = psycopg2._connect(DATABASE_URL)
def __init__(self):
curl = "dbname=%s user=%s password=%s" % (
dbconfig['dbname'], dbconfig['user'], dbconfig['password'])
self.connection = psycopg2._connect(curl)
def __init__(self):
connection_url = "dbname=jeanmerced user=postgres password=password"
self.conn = psycopg2._connect(connection_url)
def __init__(self):
""" Database connection """
connection_url = "dbname=%s user=%s password=%s" % (
pg_config['dbname'], pg_config['user'], pg_config['passwd'])
self.conn = psycopg2._connect(connection_url)
def __init__(self):
connection_url = "dbname=photo_app_db user=postgres password=qwerty"
self.conn = psycopg2._connect(connection_url)
def renderTile(self, width, height, srs, coord):
""" Render a single tile, return a SaveableResponse instance.
"""
db = _connect(**self.dbkwargs).cursor()
prepare_database(db, coord, self.layer.projection)
counts = []
# Select core node information
db.execute("""SELECT n.id, n.version, EXTRACT(epoch FROM n.tstamp),
u.id, u.name, n.changeset_id,
ST_Y(n.geom), ST_X(n.geom)
FROM nodes n
LEFT OUTER JOIN users u
ON n.user_id = u.id
INNER JOIN box_node_list b
ON b.id = n.id
ORDER BY n.id""")
nodes = [Node(*row) for row in db.fetchall()]
nodes_dict = dict([(node.id, node) for node in nodes])
# Select all node tags
db.execute("""SELECT n.id, t.k, t.v
FROM node_tags t
INNER JOIN box_node_list n
ON n.id = t.node_id
ORDER BY n.id""")
for (node_id, key, value) in db.fetchall():
nodes_dict[node_id].tag(key, value)
# Select core way information
db.execute("""SELECT w.id, w.version, EXTRACT(epoch FROM w.tstamp),
u.id, u.name, w.changeset_id
FROM ways w
LEFT OUTER JOIN users u
ON w.user_id = u.id
INNER JOIN box_way_list b
ON b.id = w.id
ORDER BY w.id""")
ways = [Way(*row) for row in db.fetchall()]
ways_dict = dict([(way.id, way) for way in ways])
# Select all way tags
db.execute("""SELECT w.id, t.k, t.v
FROM way_tags t
INNER JOIN box_way_list w
ON w.id = t.way_id
ORDER BY w.id""")
for (way_id, key, value) in db.fetchall():
ways_dict[way_id].tag(key, value)
# Select all way nodes in order
db.execute("""SELECT w.id, n.node_id, n.sequence_id
FROM way_nodes n
INNER JOIN box_way_list w
ON n.way_id = w.id
ORDER BY w.id, n.sequence_id""")
for (way_id, node_id, sequence_id) in db.fetchall():
ways_dict[way_id].node(node_id)
# Looks like: select core relation information
db.execute("""SELECT e.id, e.version, e.user_id, u.name AS user_name, e.tstamp, e.changeset_id
FROM relations e
LEFT OUTER JOIN users u
ON e.user_id = u.id
INNER JOIN box_relation_list c
ON e.id = c.id
ORDER BY e.id""")
counts.append(len(db.fetchall()))
# Looks like: select all relation tags
db.execute("""SELECT relation_id AS entity_id, k, v
FROM relation_tags f
INNER JOIN box_relation_list c
ON f.relation_id = c.id
ORDER BY entity_id""")
counts.append(len(db.fetchall()))
# Looks like: select all relation members in order
db.execute("""SELECT relation_id AS entity_id, member_id, member_type, member_role, sequence_id
FROM relation_members f
INNER JOIN box_relation_list c
ON f.relation_id = c.id
ORDER BY entity_id, sequence_id""")
counts.append(len(db.fetchall()))
return SaveableResponse(nodes, ways)
raise Exception(counts)
def __init__(self):
connection_url = "dbname=%s user=%s" % (pg_config['dbname'],
pg_config['user'])
self.conn = psycopg2._connect(connection_url)
def __init__(self):
connection_url = "dbname=%s person=%s password=%s" % (
pg_config['dbname'], pg_config['person'], pg_config['passwd'])
self.conn = psycopg2._connect(connection_url)
