def parseAll(pfad, bildpfad = None, substractMin=True, minimumHeight = 0.0, maximumHeight = 100.0, curveRadius=8): global topoParameter setHeights(minimumHeight, maximumHeight) topoParameter = convertTopoMap(bildpfad, pfad) minLongitude = -1 maxLongitude = 9 minLatitude = -1 maxLatitude = 55 #create rNodedict with counter for entity in parse_file(pfad): if isinstance(entity, Node): #if minLongitude <entity.lon< maxLongitude and minLatitude <entity.lat< maxLatitude: # approximate longitude and latitude of Wuppertal rNode(entity, substractMin=topoParameter) #create streetrNodedict and count rNodeuse for entity in parse_file(pfad): if isinstance(entity, Way): for word in ["highway"]:#, "lanes", "oneway", "cycleway", "foot", "sidewalk", "footway"]: if word in entity.tags and not "stairs" in entity.tags["highway"] and not "steps" in entity.tags["highway"] and not "pedestrian" in entity.tags["highway"] and not "elevator" in entity.tags["highway"] and not "footway" in entity.tags["highway"] and not "bridleway" in entity.tags["highway"] and not "cycleway" in entity.tags["highway"] and not "path" in entity.tags["highway"]: OSMPreWay(entity) for preWay in OSMPreWay.allWays.values(): preWay._evaluate() for node in rNode.allrNodes.values(): for way in node.incomingWays: node.createConnections(way) for way in node.outgoingWays: node.createConnections(way) for node in rNode.allrNodes.values(): node.createOpenDriveElements(r=curveRadius) node.createOpenDriveLanesAndInternalRoadConnections() for node in rNode.allrNodes.values(): node.connectOpenDriveLanes()
def parseAll(pfad): minLongitude = -1 maxLongitude = 9 minLatitude = -1 maxLatitude = 55 #create Nodedict with counter for entity in parse_file(pfad): if isinstance(entity, Node): if minLongitude < entity.lon < maxLongitude and minLatitude < entity.lat < maxLatitude: # approximate longitude and latitude of Wuppertal OSMNode(entity) #create streetnodedict and count nodeuse for entity in parse_file(pfad): if isinstance(entity, Way): for word in [ "highway" ]: #, "lanes", "oneway", "cycleway", "foot", "sidewalk", "footway"]: if word in entity.tags and not "stairs" in entity.tags[ "highway"] and not "steps" in entity.tags[ "highway"] and not "pedestrian" in entity.tags[ "highway"] and not "elevator" in entity.tags[ "highway"] and not "footway" in entity.tags[ "highway"] and not "bridleway" in entity.tags[ "highway"] and not "cycleway" in entity.tags[ "highway"] and not "path" in entity.tags[ "highway"]: OSMPreWay(entity) for preWay in OSMPreWay.allWays.values(): preWay._evaluate() for node in OSMNode.allOSMNodes.values(): node._evaluate()
def load_osm(filename): parsed = parse_file(filename) print("Parsed File") ways = {} nodes = {} relation = {} min_lat, max_lat, min_lon, max_lon = 360, 0, 90, -90 for entity in parsed: if isinstance(entity, Way): ways[entity.id] = entity elif isinstance(entity, Node): nodes[entity.id] = entity min_lat = min(min_lat, entity.lat) max_lat = max(max_lat, entity.lat) min_lon = min(min_lon, entity.lon) max_lon = max(max_lon, entity.lon) elif isinstance(entity, Relation): relation[entity.id] = entity else: print("Unknown entity: " + str(type(entity))) highways = {} for id, way in ways.items(): if "highway" in way.tags: highways[id] = way return highways, nodes, (min_lat, max_lat, min_lon, max_lon)
def create_walk_network_from_osm(osm_file): walk_network = networkx.Graph() assert (os.path.exists(osm_file)) ways = [] for i, entity in enumerate(parse_file(osm_file)): if isinstance(entity, Node): walk_network.add_node(entity.id, lat=entity.lat, lon=entity.lon) elif isinstance(entity, Way): if "highway" in entity.tags: if entity.tags["highway"] in OSM_HIGHWAY_WALK_TAGS: ways.append(entity) for way in ways: walk_network.add_path(way.nodes) del ways # Remove all singleton nodes (note that taking the giant component does not necessarily provide proper results. for node, degree in walk_network.degree().items(): if degree is 0: walk_network.remove_node(node) node_lats = networkx.get_node_attributes(walk_network, 'lat') node_lons = networkx.get_node_attributes(walk_network, 'lon') for source, dest, data in walk_network.edges(data=True): data["distance"] = wgs84_distance(node_lats[source], node_lons[source], node_lats[dest], node_lons[dest]) return walk_network
def convert_osmtogeojson(filename): _get_all_coordinates(filename) feature_collection = [] for item in parse_file(filename): # generator!! if isinstance(item, Node) and item.tags != {}: point = Point(dict_of_coords[item.id]) feature = Feature(geometry=point, id=item.id, properties=item.tags) feature_collection.append(feature) elif isinstance(item, Way) and 'highway' in item.tags: coords = _get_coords_of_edge(item.nodes) line_string = LineString(coords) feature = Feature(geometry=line_string, id=item.id, properties=item.tags) feature_collection.append(feature) print_info("\rParsing features - feature count: {:,}".format( len(feature_collection)).replace(",", " "), end='') print("") geojson_file = FeatureCollection(feature_collection) # with open('data/output.geojson', 'w') as outfile: # geojson.dump(geojson_file, outfile) # outfile.close() return geojson_file
def read_osm(self): print 'begin reading osm', datetime.datetime.now() osm_objs = {Node: [], Way: [], Relation: []} for obj in parse_file(self.osm_path): osm_objs[type(obj)].append(obj) print 'finish reading osm', datetime.datetime.now() return osm_objs
def decode_node_to_csv(): for entry in parse_file('./data/denmark-latest.osm'): if (isinstance(entry, Node) and 'addr:street' in entry.tags and 'addr:postcode' in entry.tags and 'addr:housenumber' in entry.tags): yield entry
def create_map_from_xml(fn, include_footways=False, include_parking=False): """Create an InMemMap from an OpenStreetMap XML file. Used for testing routes on OpenStreetMap. """ from ..map.inmem import InMemMap map_con = InMemMap("map", use_latlon=True) cnt = 0 ways_filter = ['bridleway', 'bus_guideway', 'track'] if not include_footways: ways_filter += ['footway', 'cycleway', 'path'] parking_filter = ['driveway'] if not include_parking: parking_filter += ['parking_aisle'] for entity in osmread.parse_file(str(fn)): if isinstance(entity, osmread.Way): tags = entity.tags if 'highway' in tags \ and not (tags['highway'] in ways_filter) \ and not ('access' in tags and tags['access'] == 'private') \ and not ('landuse' in tags and tags['landuse'] == 'square') \ and not ('amenity' in tags and tags['amenity'] == 'parking') \ and not ('service' in tags and tags['service'] in parking_filter) \ and not ('area' in tags and tags['area'] == 'yes'): for node_a, node_b in zip(entity.nodes, entity.nodes[1:]): map_con.add_edge(node_a, node_b) # Some roads are one-way. We'll add both directions. map_con.add_edge(node_b, node_a) if isinstance(entity, osmread.Node): map_con.add_node(entity.id, (entity.lat, entity.lon)) map_con.purge() return map_con
def get_footways(): footways = [] for entity in parse_file("map.osm"): if isinstance(entity, Way): if 'footway' in entity.tags: footways.append(entity) return footways
def load(): num_links = 0 for entity in parse_file('novi_sad.osm.pbf'): if isinstance(entity, Node): node_dict[entity.id] = entity elif isinstance( entity, Way ) and 'highway' in entity.tags: # and entity.tags['highway'] in ALLOWED_ROADS: highway_type = entity.tags['highway'] typs[highway_type] = typs.get(highway_type, 0) + 1 if highway_type not in ALLOWED_ROADS: continue if 'access' in entity.tags and entity.tags['access'] != 'yes': continue important_ways.append(entity) nodes.update(set(entity.nodes)) for i, cur in enumerate(entity.nodes[1:]): prev = entity.nodes[i] node_neighbors[prev].append((cur, entity)) if 'oneway' not in entity.tags or entity.tags['oneway'] == 'no': node_neighbors[cur].append((prev, entity)) num_links += 1 for k, i in sorted(typs.items(), key=lambda x: -x[1]): print(i, k) print('nodes:', len(nodes)) print('links:', num_links)
def main(argv=sys.argv): argparser = ArgumentParser() argparser.add_argument('filename', type=str) argparser.add_argument('-f', dest='format', metavar='format', type=str, help='file format: xml or pbf') argparser.add_argument('-c', dest='compression', metavar='compression', type=str, help='override compression autodetection: bz2') argparser.add_argument('-d', dest='dump', action='store_true', help='dump elements to stdout (debug)') args = argparser.parse_args(argv[1:]) element_count, node_count, way_count, relation_count = 0, 0, 0, 0 for e in parse_file(args.filename): element_count += 1 if isinstance(e, Node): node_count += 1 elif isinstance(e, Way): way_count += 1 elif isinstance(e, Relation): relation_count += 1 if args.dump: print repr(e) print "%d elements read (nodes=%d, ways=%d, relations=%d)" % (element_count, node_count, way_count, relation_count)
def process_osm_file(osm_file_path, limit): """Process OSM file, converting to a list of dict. Keyword arguments: osm_file_path -- str path of the OSM file limit -- number of records to store Returns: entities_list -- list of dict """ entities_list = list() osm_file = parse_file(osm_file_path) for i, entity in enumerate(osm_file): print '|'.join([str(i), str(len(entities_list))]) try: if len(entity.tags) > 0 and entity.lat and entity.lon: loc = ','.join([str(entity.lat), str(entity.lon)]) entities = dict() response = list() indexable = set() if 'name' in entity.tags: response.append(entity.tags['name']) if 'addr:housenumber' in entity.tags: response.append(entity.tags['addr:housenumber']) if 'addr:street' in entity.tags: response.append(entity.tags['addr:street']) if 'addr:city' in entity.tags: response.append(entity.tags['addr:city']) if 'postal_code' in entity.tags: response.append(entity.tags['postal_code']) if len(response) == 0: continue response = ','.join(response) for key, value in entity.tags.iteritems(): indexable.add(value) indexable = ' '.join(indexable) entities['id'] = len(entities_list) + 1 entities['fields'] = {} entities['fields']['response'] = response entities['fields']['indexable'] = indexable entities['fields']['location_field'] = loc entities['type'] = 'add' print entities entities_list.append(entities) except Exception, e: print e pass if len(entities_list) == limit: break
def init(region): nodes = [] for entity in parse_file( '/home/pouria/Downloads/osm/{}.osm'.format(region)): if isinstance(entity, Node): nodes.append([entity.lat, entity.lon]) return cKDTree(nodes), {}
def decode_node_to_csv(): # Dictionary with geo-locations of each address to use as strings for entry in parse_file('./data/denmark-latest.osm'): if (isinstance(entry, Node) and 'addr:street' in entry.tags and 'addr:postcode' in entry.tags and 'addr:housenumber' in entry.tags): yield entry
def decode_node_to_csv(filename): for entry in parse_file('/data/osm/' + filename): if (isinstance(entry, Node) and 'addr:street' in entry.tags and 'addr:postcode' in entry.tags and 'addr:housenumber' in entry.tags and 'addr:city' in entry.tags): yield entry
def read_osm(self): print 'begin reading osm', datetime.datetime.now() osm_objs = {'Node': [], 'Way': [], 'Relation': []} for obj in parse_file(self.osm_path): type_str = self.get_type_str(type(obj)) osm_objs[type_str].append(obj) print 'finish reading osm', datetime.datetime.now() return osm_objs
def _get_all_coordinates(filename): for item in parse_file(filename): # generator!! if isinstance(item, Node): dict_of_coords[item.id] = (item.lon, item.lat) print_info("\rParsing all coordinates - node count: {:,}".format( len(dict_of_coords)).replace(",", " "), end='') print("")
def process_map_with_osmread(self, filename): """ Process one map given its filename, using osmread """ # This import is here since user doesn't have to have it (optional) from osmread import parse_file for raw_entity in parse_file(filename): self._entity_found(raw_entity)
def file_to_map(filename, map_con): logger.debug("Parse OSM file ...") for entity in osmread.parse_file(str(filename)): if isinstance(entity, osmread.Way) and 'highway' in entity.tags: for node_a, node_b in zip(entity.nodes, entity.nodes[1:]): map_con.add_edge(node_a, node_b) # Some roads are one-way. We'll add both directions. map_con.add_edge(node_b, node_a) if isinstance(entity, osmread.Node): map_con.add_node(entity.id, (entity.lat, entity.lon)) logger.debug("... done") logger.debug("Purging database ...") map_con.purge() logger.debug("... done")
def create_map_osmread() -> None: xml_file = Path("./tests") / "osm.xml" map_con = InMemMap("myosm", use_latlon=True, use_rtree=True, index_edges=True) for entity in osmread.parse_file(str(xml_file)): if isinstance(entity, osmread.Way) and 'highway' in entity.tags: for node_a, node_b in zip(entity.nodes, entity.nodes[1:]): map_con.add_edge(node_a, node_b) # Some roads are one-way. We'll add both directions. map_con.add_edge(node_b, node_a) if isinstance(entity, osmread.Node): map_con.add_node(entity.id, (entity.lat, entity.lon)) map_con.purge()
def get(self): file_path = join(dirname(realpath(__file__)), '../files/kansai-latest.osm.pbf') # print(file_path) shop_count = 0 for entity in parse_file(file_path): if shop_count < 10: if isinstance(entity, Node) and 'shop' in entity.tags: shop_count += 1 print(entity) # データベースに追加 # ~~~~~~ print(shop_count) return jsonify({"message": "OSM"})
def import_osm(self, debug=False): # Mysql prep add_node = ("INSERT INTO node " "(id, lat, lng) " "VALUES (%s, %s, %s)") add_edge = ("INSERT INTO edge " "(n1id, n2id, oneway, speed, name, type, distance) " "VALUES (%s, %s, %s, %s, %s, %s, %s)") count_nodes = 0 count_edges = 0 try: for entity in parse_file(self.file_path): # Find nodes if isinstance(entity, Node): data_node = (str(entity.id), str(entity.lat), str(entity.lon)) self.cursor.execute(add_node, data_node) count_nodes += 1 if debug: print("Node {} processed.".format(entity.id)) # Find edges if isinstance(entity, Way) and 'highway' in entity.tags: number_of_node_relationships = len(entity.nodes) if number_of_node_relationships > 2: # Must mean that the road is divided up between multiple nodes for x in range(0, number_of_node_relationships - 1): path = Path(entity, entity.nodes[x], entity.nodes[x + 1]) data_edge = (path.start_node, path.end_node, path.oneway, path.speed, path.name, path.type, "0") self.cursor.execute(add_edge, data_edge) count_edges += 1 if debug: print("Edge {} processed.".format(path.id)) elif number_of_node_relationships == 2: path = Path(entity, entity.nodes[0], entity.nodes[1]) data_edge = (path.start_node, path.end_node, path.oneway, path.speed, path.name, path.type, "0") self.cursor.execute(add_edge, data_edge) count_edges += 1 if debug: print("Edge {} processed.".format(path.id)) except mysql.connector.errors.IntegrityError: # If entity already exists in db then skip pass self.cnx.commit() return "Number of nodes found: {}\nNumber of edges found: {}".format(count_nodes, count_edges)
def decode_node_to_csv(): mycount = 0 postcodes = defaultdict(list) for entry in parse_file('./denmark-latest.osm'): mycount += 1 if (isinstance(entry, Node) and 'addr:street' in entry.tags and 'addr:postcode' in entry.tags and 'addr:city' in entry.tags and 'lat' in entry and 'lon' in entry and 'addr:housenumber' in entry.tags): address_field = entry.tags['addr:city'] zip_field = entry.tags['addr:postcode'] search_address = ' '.join([zip_field, address_field]) street_field = entry.tags['addr:street'] houseno_field = entry.tags['addr:housenumber'] search_street = ' '.join([street_field, houseno_field]) my_tuple = (search_street, entry.lat, entry.lon) postcodes[search_address].append(my_tuple) print(mycount) return postcodes
def findNearestBusStop(inputNode): """ Returns the nearest bus stop to the input node """ busStops = [] # Empty list to store nodes representing bus stops mapData = osmread.parse_file("trimmed.osm") for entity in mapData: if isinstance(entity, osmread.Node) and 'highway' in entity.tags: if entity.tags["highway"] == "bus_stop": busStops.append(entity) shortestDistance = 100 for busStop in busStops: distance = getNodeDist(inputNode, busStop) if distance < shortestDistance: shortestDistance = distance closestBusStop = busStop return closestBusStop
def file_converter(osm_file): elements = [] # Extract the nodes and the ways for entity in osmread.parse_file(osm_file): json_data = {} if isinstance(entity, osmread.Node): json_data = read_node(entity) elif isinstance(entity, osmread.Way): json_data = read_way(entity) elif isinstance(entity, osmread.Relation): json_data = read_relation(entity) elements.append(json_data) # response_jsons return [{'elements': elements}]
def read_osm(filepath): nodes = {} ways = [] # rels = [] # Extract the nodes and the ways for entity in osmread.parse_file(filepath): if isinstance(entity, osmread.Node): # don't really need anything about the nodes except their lon and lat i don't think nodes[entity.id] = (entity.lon, entity.lat) elif isinstance(entity, osmread.Way) and (not ways_filter(entity.tags)): # convert speed limit from string to int. # NOTE: assumes in US/all limits are in MPH if 'maxspeed' in entity.tags: try: entity.tags['maxspeed'] = int(entity.tags['maxspeed'][:-4]) except ValueError: try: # someone probably forgot to put a mph on it entity.tags['maxspeed'] = int(entity.tags['maxspeed']) except ValueError: # blank maxspeed, probably del entity.tags['maxspeed'] # treat links like regular roads if entity.tags['highway'][-5:] == '_link': entity.tags['highway'] = entity.tags['highway'][:-5] # ensure consistency on lanes entity.tags['lanes'] = int(entity.tags.get('lanes', 0)) ways.append(entity) # elif isinstance(entity, osmread.Relation) and (not rels_filter(entity.tags)): # rels.append(entity) # TBD what to do with this # return nodes, ways, rels return nodes, ways
def main(argv=sys.argv): argparser = ArgumentParser() argparser.add_argument('filename', type=str) argparser.add_argument('-f', dest='format', metavar='format', type=str, help='file format: xml or pbf') argparser.add_argument('-c', dest='compression', metavar='compression', type=str, help='override compression autodetection: bz2') argparser.add_argument('-d', dest='dump', action='store_true', help='dump elements to stdout (debug)') args = argparser.parse_args(argv[1:]) element_count, node_count, way_count, relation_count = 0, 0, 0, 0 for e in parse_file(args.filename): element_count += 1 if isinstance(e, Node): node_count += 1 elif isinstance(e, Way): way_count += 1 elif isinstance(e, Relation): relation_count += 1 if args.dump: print(repr(e)) print("%d elements read (nodes=%d, ways=%d, relations=%d)" % (element_count, node_count, way_count, relation_count))
def _ways(name): try: with open(_dir + name + '.pkl', 'rb') as f: return pickle.load(f) except FileNotFoundError as e: __ways = {} for entity in parse_file(_dir + name + '.osm'): if isinstance(entity, Node): __ways[entity.id] = (entity.lat, entity.lon) if isinstance(entity, Way) and 'highway' in entity.tags: highway = entity.tags['highway'] speed = int(entity.tags['maxspeed'] ) if 'maxspeed' in entity.tags else default.get( highway, 20) nodes = entity.nodes nodes = [ nodes[i * 5:min(i * 5 + 5, len(nodes))] for i in range(math.ceil(len(nodes) / 5)) ] if len(nodes[-1]) == 1: nodes[-2] = list(nodes[-2]) nodes[-2].append(nodes[-1][0]) nodes = nodes[:-1] for points in nodes: __ways[(points[0], points[-1])] = { 'highway': highway, 'speed': [speed, speed], 'nodes': points } if 'oneway' not in entity.tags or entity.tags[ 'oneway'] == 'no': __ways[(points[-1], points[0])] = { 'highway': highway, 'speed': [speed, speed], 'nodes': tuple(reversed(points)) } with open(_dir + name + '.pkl', 'wb') as f: pickle.dump(__ways, f, pickle.HIGHEST_PROTOCOL) return __ways
def calculate_osm_stats(self, osm_path): """ reads the .osm file and captures certain stats like last update and number of ways, etc... """ log.info("calculating stats for {}".format(osm_path)) self.osm_file = osm_path for entity in parse_file(osm_path): if isinstance(entity, Way): self.way_count += 1 if 'highway' in entity.tags: self.highway_count += 1 if entity.timestamp > self.last.timestamp: self.last.timestamp = entity.timestamp self.last.id = entity.id if entity.changeset > 0: self.last.changeset = entity.changeset self.last.edit_date = date_utils.pretty_date_from_ms(self.last.timestamp * 1000, fmt="%B %d, %Y") self.last.file_date = file_utils.file_pretty_date(osm_path, fmt="%B %d, %Y") # if available, add the changeset url if self.last.changeset > 0: self.last.changeset_url = "http://openstreetmap.org/changeset/{}".format(self.last.changeset)
def getNodesAndEdges(): # nodes maps {ID:MapNode} nodes = dict() #edges maps {ID:[Edge....]} nodeEdges = dict() #edges {ID: Edge} edges = dict() for entity in parse_file('data/map.osm'): if isinstance(entity, Node): node = MapNode(entity.id, entity.lat, entity.lon) nodes[entity.id] = node if isinstance(entity, Way) and 'highway' in entity.tags: path = entity.nodes edgeID = entity.id for i in range(len(path) - 1): # dist = Utils.euclid(nodes[path[i]].point, nodes[path[i+1]].point) n1ID = path[i] n2ID = path[i + 1] edge = Edge(int(str(edgeID) + str(i)), nodes[n1ID], nodes[n2ID]) edges[int(str(edgeID) + str(i))] = edge if n1ID in nodeEdges: nodeEdges[n1ID].append(edge) else: nodeEdges[n1ID] = [edge] if n2ID in nodeEdges: nodeEdges[n2ID].append(edge) else: nodeEdges[n2ID] = [edge] prunedNodes = dict() for nID in nodes.keys(): if nID in nodeEdges: prunedNodes[nID] = nodes[nID] return (prunedNodes, nodeEdges, edges)
from osmread import parse_file, Way hillcenters = 0 for entity in parse_file('Rutgers Pathways.osm'): if isinstance(entity, Way) and 'name' in entity.tags: #Now we check what the name of a given Way is to see the way that represents the hill center #entity.tags (in this case Way.tags because we are choosing ways) is a dictionary with a # variety of info about the particular way, print out an entity.tags to see all the info if entity.tags['name'] == "Hill Center Bldg For The Mathematical Sciences": hillcenters += 1 print("%s hill centers found" % hillcenters)
def getData(location): return parse_file(location)
from osmread import parse_file, Way highway_count = 0 for entity in parse_file('map_small.osm'): if isinstance(entity, Way) and 'highway' in entity.tags: highway_count += 1 print(highway_count)
from osmread import parse_file, Way, Relation, Node import json from pprint import pprint with open('../data/buildings.json') as f: data = json.load(f) #datum of format {u'latitude': u'37.8723', u'name': u'Bancroft Library/University Archives', u'longitude': u'-122.2587'} for datum in data: print(datum['latitude'], datum['longitude']) build_count = 0 node_count = 0 for entity in parse_file('../data/berkeley_map.osm'): if 'building' in entity.tags.keys(): #if a building build_count += 1 #print(entity.tags) if isinstance(entity, Node): node_count += 1 #print("%d buildings found, %d nodes found" % (build_count, node_count))
import sys import json from osmread import parse_file, Way, Node, Relation tic = time.clock() # url = 'http://www.overpass-api.de/api/xapi_meta?*[building=yes][bbox=55.09094238281249,24.931898803604035,55.33538818359375,25.116067121686175]' # fileOSM = urllib2.urlopen(url) # with open('buildings.osm','wb') as output: # output.write(fileOSM.read()) vecNodes = {} geoJson = {} geoJson['type'] = 'FeatureCollection' geoJson['crs'] = { "type": "name", "properties": { "name": "urn:ogc:def:crs:OGC:1.3:CRS84" } } geoJson['features'] = [] for entity in parse_file('buildings.osm'): if isinstance(entity, Node): vecNodes[str(entity.id)] = {'lat':entity.lat,'lng':entity.lon} elif isinstance(entity, Way): vecPolygon = [] for node in entity.nodes: vecPolygon.append([vecNodes[str(node)]['lng'],vecNodes[str(node)]['lat']]) dataFeature = {} dataFeature['type']='Feature' dataFeature['properties']={} dataFeature['geometry']={} dataFeature['geometry']['type']='Polygon' dataFeature['geometry']['coordinates']=[vecPolygon] geoJson['features'].append(dataFeature) with open('data.geojson', 'w') as outfile: json.dump(geoJson, outfile)