Improve iter_points

folium/features.py

@@ -17,7 +17,7 @@
 from branca.utilities import (_locations_tolist, _parse_size, image_to_url, iter_points, none_max, none_min)  # noqa
 
 from folium.map import FeatureGroup, Icon, Layer, Marker
-from folium.utilities import _parse_wms
+from folium.utilities import _parse_wms, get_bounds
 from folium.vector_layers import PolyLine
 
 from jinja2 import Template
@@ -510,37 +510,13 @@ def style_data(self):
             feature.setdefault('properties', {}).setdefault('highlight', {}).update(self.highlight_function(feature))  # noqa
         return json.dumps(self.data, sort_keys=True)
 
-    def get_bounds(self):
+    def _get_self_bounds(self):
         """
         Computes the bounds of the object itself (not including it's children)
-        in the form [[lat_min, lon_min], [lat_max, lon_max]]
+        in the form [[lat_min, lon_min], [lat_max, lon_max]].
 
         """
-        if not self.embed:
-            raise ValueError('Cannot compute bounds of non-embedded GeoJSON.')
-
-        if 'features' not in self.data.keys():
-            # Catch case when GeoJSON is just a single Feature or a geometry.
-            if not (isinstance(self.data, dict) and 'geometry' in self.data.keys()):  # noqa
-                # Catch case when GeoJSON is just a geometry.
-                self.data = {'type': 'Feature', 'geometry': self.data}
-            self.data = {'type': 'FeatureCollection', 'features': [self.data]}
-
-        bounds = [[None, None], [None, None]]
-        for feature in self.data['features']:
-            for point in iter_points(feature.get('geometry', {}).get('coordinates', {})):  # noqa
-                bounds = [
-                    [
-                        none_min(bounds[0][0], point[1]),
-                        none_min(bounds[0][1], point[0]),
-                        ],
-                    [
-                        none_max(bounds[1][0], point[1]),
-                        none_max(bounds[1][1], point[0]),
-                        ],
-                    ]
-        return bounds
-
+        return get_bounds(self.data, lonlat=True)
 
 class TopoJson(Layer):
     """

folium/utilities.py

@@ -338,33 +338,53 @@ def none_max(x, y):
         return max(x, y)
 
 
-def iter_points(x):
-    """Iterates over a list representing a feature, and returns a list of points,
-    whatever the shape of the array (Point, MultiPolyline, etc).
+def iter_coords(obj):
     """
-    if isinstance(x, (list, tuple)):
-        if len(x):
-            if isinstance(x[0], (list, tuple)):
-                out = []
-                for y in x:
-                    out += iter_points(y)
-                return out
-            else:
-                return [x]
+    Returns all the coordinate tuples from a geometry or feature.
+
+    """
+    if isinstance(obj, (tuple, list)):
+        coords = obj
+    elif 'features' in obj:
+        coords = [geom['geometry']['coordinates'] for geom in obj['features']]
+    elif 'geometry' in obj:
+        coords = obj['geometry']['coordinates']
+    else:
+        coords = obj.get('coordinates', obj)
+    for coord in coords:
+        if isinstance(coord, (float, int)):
+            yield tuple(coords)
+            break
         else:
-            return []
+            for f in iter_coords(coord):
+                yield f
+
+
+def _locations_mirror(x):
+    """
+    Mirrors the points in a list-of-list-of-...-of-list-of-points.
+    For example:
+    >>> _locations_mirror([[[1, 2], [3, 4]], [5, 6], [7, 8]])
+    [[[2, 1], [4, 3]], [6, 5], [8, 7]]
+
+    """
+    if hasattr(x, '__iter__'):
+        if hasattr(x[0], '__iter__'):
+            return list(map(_locations_mirror, x))
+        else:
+            return list(x[::-1])
     else:
-        raise ValueError('List/tuple type expected. Got {!r}.'.format(x))
+        return x
 
 
-def get_bounds(locations):
+def get_bounds(locations, lonlat=False):
     """
     Computes the bounds of the object in the form
     [[lat_min, lon_min], [lat_max, lon_max]]
 
     """
     bounds = [[None, None], [None, None]]
-    for point in iter_points(locations):
+    for point in iter_coords(locations):
         bounds = [
             [
                 none_min(bounds[0][0], point[0]),
@@ -375,4 +395,6 @@ def get_bounds(locations):
                 none_max(bounds[1][1], point[1]),
             ],
         ]
+    if lonlat:
+        bounds = _locations_mirror(bounds)
     return bounds