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)