added support for multipolygons

Author: t-g-williams

overpass/api.py

@@ -2,9 +2,10 @@
 import json
 import geojson
 import logging
+import code
 
 from .errors import (OverpassSyntaxError, TimeoutError, MultipleRequestsError,
-                     ServerLoadError, UnknownOverpassError, ServerRuntimeError)
+                      ServerLoadError, UnknownOverpassError, ServerRuntimeError)
 
 class API(object):
     """A simple Python wrapper for the OpenStreetMap Overpass API"""
@@ -135,6 +136,7 @@ def _GetFromOverpass(self, query):
     def _asGeoJSON(self, elements):
 
         features = []
+        no_match_count = 0
         for elem in elements:
             elem_type = elem["type"]
             if elem_type == "node":
@@ -164,7 +166,55 @@ def _asGeoJSON(self, elements):
                 # conditions
                 prev = "inner"
                 not_first = False
-                for mem in elem["members"]:
+
+                for pos in range(len(elem["members"])):
+                    mem = elem['members'][pos]
+
+                    # check whether the coordinates of the next member need to be reversed
+                    # also sometimes the next member may not actually connect to the previous member, so if necessary, find a matching member
+                    if points != []:
+                        dist_start = (points[-1][0] - mem["geometry"][0]["lon"])**2 + (points[-1][1] - mem["geometry"][0]["lat"])**2
+                        dist_end = (points[-1][0] - mem["geometry"][-1]["lon"])**2 + (points[-1][1] - mem["geometry"][-1]["lat"])**2
+                        if dist_start == 0:
+                            pass # don't need to do anything
+                        elif dist_end == 0:
+                            # flip the next member - it is entered in the wrong direction
+                            mem["geometry"] = list(reversed(mem["geometry"]))
+                        else:
+                            # try flipping the previous member
+                            dist_flipped_start = (points[0][0] - mem["geometry"][0]["lon"])**2 + (points[0][1] - mem["geometry"][0]["lat"])**2
+                            dist_flipped_end = (points[0][0] - mem["geometry"][-1]["lon"])**2 + (points[0][1] - mem["geometry"][-1]["lat"])**2
+                            if dist_flipped_start == 0:
+                                # just flip the start
+                                points = list(reversed(points))
+                            elif dist_flipped_end == 0:
+                                # both need to be flipped
+                                points = list(reversed(points))
+                                mem["geometry"] = list(reversed(mem["geometry"]))
+                            else:
+                                # no matches -- look for a new match
+                                point_found = False
+                                for i in range(pos + 1, len(elem['members'])):
+                                    if not point_found:
+                                        new_pt = elem['members'][i]
+                                        dist_start = (new_pt['geometry'][0]['lon'] - points[-1][0])**2 + (new_pt['geometry'][0]['lat'] - points[-1][1])**2
+                                        dist_end = (new_pt['geometry'][-1]['lon'] - points[-1][0])**2 + (new_pt['geometry'][-1]['lat'] - points[-1][1])**2
+                                        
+                                        if dist_start == 0 or dist_end == 0:
+                                            point_found = True
+                                            # swap the order of the members -- we have found the one we want
+                                            elem['members'][pos], elem['members'][i] = elem['members'][i], elem['members'][pos]
+                                            # save this new point as mem
+                                            mem = elem['members'][pos]
+
+                                            if dist_end == 0:
+                                                mem['geometry'] = list(reversed(mem['geometry']))
+
+                                if not point_found:
+                                    no_match_count += 1
+                                    # don't work with this park
+                                    continue
+                           
                     # address outer values
                     if mem['role'] == 'outer':
                         if prev == "inner":
@@ -175,13 +225,15 @@ def _asGeoJSON(self, elements):
                             # append the previous poly to the polygon list
                             polygons.append(poly)
                             poly = []
-                        
+
                         for coords in mem["geometry"]:
-                            points.append([coords["lon"], coords["lat"]])
+                            try:
+                                points.append([coords["lon"], coords["lat"]])
+                            except:
+                                code.interact(local=locals())
 
                         if points[-1] == points[0]:
                             # finish the outer polygon if it has met the start
-                            is_complete = True
                             poly.append(points)
                             points = []
                         # update condition
@@ -200,20 +252,23 @@ def _asGeoJSON(self, elements):
                         prev = "inner"
 
                     not_first = True
-                #
+
+                # add in the final poly
                 polygons.append(poly)
 
                 if polygons != [[]]:
-                    # create MultiPolygon feature
-                    poly_props = elem.get("tags")
-                    poly_props.update({'id':elem['id']})
-                    multipoly = {"type": "Feature",
-                    "properties" : poly_props,
-                    "geometry": {
-                    "type": "MultiPolygon",
-                    "coordinates": polygons}}
-
-                    # add to features
-                    features.append(multipoly)
-
-        return geojson.FeatureCollection(features)
+                    # create MultiPolygon feature - separate multipolygon for each outer
+                    for outer_poly in polygons:
+                        poly_props = elem.get("tags")
+                        poly_props.update({'id':elem['id']})
+                        multipoly = {"type": "Feature",
+                        "properties" : poly_props,
+                        "geometry": {
+                        "type": "MultiPolygon",
+                        "coordinates": [outer_poly]}}
+
+                        # add to features
+                        features.append(multipoly)
+                   
+        print('number of unmatched parks: {}'.format(no_match_count))
+        return geojson.FeatureCollection(features)