Add missing tests and features

ghiggi · ghiggi · commit 478fc5ff5b89 · 2022-11-09T16:02:14.000+01:00
diff --git a/pyresample/future/spherical/extent.py b/pyresample/future/spherical/extent.py
@@ -53,7 +53,7 @@ def _get_list_extents_from_args(args):
     if len(list_extents) == 4 and isinstance(list_extents[0], numbers.Number):
         list_extents = [list_extents]
     # Ensure that here after is a list of extents
-    if not isinstance(list_extents[0], (tuple, list)):
+    if not isinstance(list_extents[0], (tuple, list, np.ndarray)):
         raise ValueError("SExtent expects a single extent or a list of extents.")
     return list_extents
 
@@ -70,6 +70,7 @@ def _check_extent_values(extent, use_radians=False):
     """Check extent value validity."""
     lat_valid_range = [-90.0, 90.0]
     lon_valid_range = [-180.0, 180.0]
+    extent = np.array(extent)
     if use_radians:
         lat_valid_range = np.deg2rad(lat_valid_range)
         lon_valid_range = np.deg2rad(lon_valid_range)
@@ -79,11 +80,20 @@ def _check_extent_values(extent, use_radians=False):
         raise ValueError(f'extent latitude values must be within {lat_valid_range}.')
 
 
+def _check_is_not_point_extent(extent):
+    """Check the extent does not represent a point."""
+    if extent[0] == extent[1] and extent[2] == extent[3]:
+        raise ValueError("An extent can not be defined by a point.")
+
+
+def _check_is_not_line_extent(extent):
+    """Check the extent does not represent a line."""
+    if extent[0] == extent[1] or extent[2] == extent[3]:
+        raise ValueError("An extent can not be defined by a line.")
+
+
 def _check_valid_extent(extent, use_radians=False):
     """Check lat/lon extent validity."""
-    # Check extent dtype
-    if not isinstance(extent, (tuple, list, np.ndarray)):
-        raise TypeError("'extent' must be a list, tuple or np.array. [lon_min, lon_max, lat_min, lat_max].")
     # Check extent length
     if len(extent) != 4:
         raise ValueError("'extent' must have length 4: [lon_min, lon_max, lat_min, lat_max].")
@@ -92,38 +102,67 @@ def _check_valid_extent(extent, use_radians=False):
     # Check order and values
     _check_extent_order(extent)
     _check_extent_values(extent, use_radians=use_radians)
+    # Check is not point or line
+    _check_is_not_point_extent(extent)
+    _check_is_not_line_extent(extent)
     # Ensure is a list
     extent = extent.tolist()
     return extent
 
 
-def _check_topology_validity(polygons):
-    """Check that the extents polygons do not overlap."""
-    from shapely.topology import TopologicalError
-    try:
-        # TODO: improve to raise error also when duplicate geometries or within on another
-        # TopologicalError: The operation 'GEOSIntersects_r' could not be performed.
-        # Likely cause is invalidity of the geometry
-        polygons.intersects(polygons)
-    except TopologicalError:
-        raise ValueError("The extent list is not valid. The composing extents must not overlap each other.")
+def _check_non_overlapping_extents(polygons):
+    """Check that the extents polygons are non-overlapping.
+
+    Note: Touching extents are considered valids.
+    """
+    for poly in polygons:
+        # Intersects includes within/contain/equals/touches !
+        n_intersects = np.sum([p.intersects(poly) and not p.touches(poly) for p in polygons])
+        if n_intersects >= 2:
+            raise ValueError("The extents composing SExtent can not be duplicates or overlapping.")
+
+
+def _is_global_extent(polygons):
+    """Check if a list of extents composes a global extent."""
+    from shapely.geometry import Polygon
+    from shapely.ops import unary_union
+
+    # Try union the polygons
+    unioned_polygon = unary_union(polygons)
+    # If still a MultiPolygon, not a global extent
+    if not isinstance(unioned_polygon, Polygon):
+        return False
+    # Define global polygon
+    global_polygon = Polygon.from_bounds(-180, -90, 180, 90)
+    # Assess if global
+    is_global = global_polygon.equals(unioned_polygon)
+    return is_global
 
 
 class SExtent(object):
     """Spherical Extent.
 
     SExtent longitudes are defined between -180 and 180 degree.
+    Geometrical operations are performed on a planar coordinate system.
+
     A spherical geometry crossing the anti-meridian will have an SExtent
      composed of [lon_start, 180, ...,...] and [-180, lon_end, ..., ...]
 
-    The extents composing an SExtent:
-    - can not intersect/overlap each other
-    - can touch each other
+    Important notes:
+    - SExtents touching at the anti-meridian are considered to not touching !
+    - SExtents.intersects predicate includes also contains/within cases.
+    - In comparison to shapely polygon behaviour, SExtent.intersects is
+      False if SExtents are just touching.
 
-    There is not an upper limit on the number of extents composing SExtent.
-    The only conditions is that the extents do not intersect/overlap.
+    There is not an upper limit on the number of extents composing SExtent !!!
+    The only conditions is that the extents do not intersect/overlap each other.
 
-    Examples of valid SExtent inputs
+    More specifically, extents composing an SExtent:
+    - must represent a polygon (not a point or a line),
+    - can touch each other,
+    - but can not intersect/contain/overlap each other.
+
+    Examples of valid SExtent definitions:
       extent = [x_min, x_max, y_min, ymax]
       sext = SExtent(extent)
       sext = SExtent([extent, extent])
@@ -139,8 +178,8 @@ def __init__(self, *args):
         # Pre-compute shapely polygon
         list_polygons = [Polygon.from_bounds(*bounds_from_extent(ext)) for ext in self.list]
         self.polygons = MultiPolygon(list_polygons)
-        # Check topological validitiy of extent polygons
-        _check_topology_validity(self.polygons)
+        # Check topological validity of extents polygons
+        _check_non_overlapping_extents(self.polygons)
 
     def to_shapely(self):
         """Return the shapely extent rectangle(s) polygon(s)."""
@@ -158,31 +197,45 @@ def __iter__(self):
         """Get extents iterator."""
         return self.list.__iter__()
 
+    def _repr_svg_(self):
+        """Display the SExtent in the Ipython terminal."""
+        return self.to_shapely()._repr_svg_()
+
     @property
     def is_global(self):
         """Check if the extent is global."""
-        if len(self.list) != 1:
-            return False
-        if self.list[0] == [-180, 180, -90, 90]:
-            return True
-        else:
+        from shapely.geometry import Polygon
+        from shapely.ops import unary_union
+
+        # Try union the polygons
+        unioned_polygon = unary_union(self.polygons)
+        # If still a MultiPolygon, not a global extent
+        if not isinstance(unioned_polygon, Polygon):
             return False
+        # Define global polygon
+        global_polygon = Polygon.from_bounds(-180.0, -90.0, 180.0, 90.0)
+        # Assess if global
+        is_global = global_polygon.equals(unioned_polygon)
+        return is_global
 
     def intersects(self, other):
         """Check if SExtent is intersecting the other SExtent.
 
-        Touching extent are considered to not intersect !
+        Touching SExtent are considered to not intersect !
+        SExtents intersection also includes contains/within occurence.
         """
         if not isinstance(other, SExtent):
             raise TypeError("SExtent.intersects() expects a SExtent class instance.")
+        # Important caveat in comparison to shapely !
+        # In shapely, intersects includes touching geometries !
         bl = (self.to_shapely().intersects(other.to_shapely()) and
               not self.to_shapely().touches(other.to_shapely()))
         return bl
 
     def disjoint(self, other):
         """Check if SExtent does not intersect (and do not touch) the other SExtent."""
         if not isinstance(other, SExtent):
-            raise TypeError("SExtent.intersects() expects a SExtent class instance.")
+            raise TypeError("SExtent.disjoint() expects a SExtent class instance.")
         return self.to_shapely().disjoint(other.to_shapely())
 
     def within(self, other):
@@ -198,7 +251,14 @@ def contains(self, other):
         return self.to_shapely().contains(other.to_shapely())
 
     def touches(self, other):
-        """Check if SExtent external touches another SExtent."""
+        """Check if SExtent external touches another SExtent.
+
+        Important notes:
+        - Touching SExtents are not disjoint !
+        - Touching SExtents are considered to not intersect !
+        - SExtents which are contained/within each other AND are "touching in the interior"
+          are not considered touching !
+        """
         if not isinstance(other, SExtent):
             raise TypeError("SExtent.touches() expects a SExtent class instance.")
         return self.to_shapely().touches(other.to_shapely())
diff --git a/pyresample/test/test_sgeom/test_extent.py b/pyresample/test/test_sgeom/test_extent.py
@@ -50,12 +50,12 @@ def test_sextent_with_bad_value(self):
             SExtent(extent)
 
         # lat_min < -90
-        extent = [-180, 181, -91, 40]
+        extent = [50, 60, -91, 40]
         with pytest.raises(ValueError):
             SExtent(extent)
 
         # lat_max > 90
-        extent = [-180, 181, -40, 91]
+        extent = [50, 60, -40, 91]
         with pytest.raises(ValueError):
             SExtent(extent)
 
@@ -92,59 +92,87 @@ def test_sextent_with_bad_input(self):
         with pytest.raises(ValueError):
             SExtent(list_extent)
 
-    def test_sextent_with_correct_values(self):
-        """Test it creates the SExtent when providing correct values."""
-        # - Classic
+    def test_sextent_with_correct_format(self):
+        """Test SExtent when providing correct extent(s) format and values."""
+        # Accept list
         extent = [-180, -175, -40, 40]
         assert list(SExtent(extent))[0] == extent
-        # - Same lon
-        extent = [0, 0, -40, 40]
-        assert list(SExtent(extent))[0] == extent
-        # - Same lat
-        extent = [-10, 0, 40, 40]
-        assert list(SExtent(extent))[0] == extent
-        # - Same lat, lon (--> point extent)
-        extent = [0, 0, 40, 40]
-        assert list(SExtent(extent))[0] == extent
-        # Accept numpy array
-        extent = np.array([-180, -175, -40, 40])
-        assert list(SExtent(extent))[0] == extent.tolist()
         # Accept tuple
         extent = (-180, -175, -40, 40)
         assert list(SExtent(extent))[0] == list(extent)
-        # Accept list of extents
+        # Accept numpy array
+        extent = np.array([-180, -175, -40, 40])
+        assert list(SExtent(extent))[0] == extent.tolist()
+
+        # Accept list of extents (list)
         extent1 = [50, 60, -40, 40]
         extent2 = [175, 180, -40, 40]
         list_extent = [extent1, extent2]
         assert np.allclose(list(SExtent(list_extent)), list_extent)
-        # Accept multiple extents
+        # Accept list of extents (tuple)
+        extent1 = (50, 60, -40, 40)
+        extent2 = (175, 180, -40, 40)
+        list_extent = [extent1, extent2]
+        assert np.allclose(list(SExtent(list_extent)), list_extent)
+        # Accept list of extents (np.array)
+        extent1 = np.array([0, 60, -40, 40])
+        extent2 = np.array([175, 180, -40, 40])
+        list_extent = [extent1, extent2]
+        assert np.allclose(list(SExtent(list_extent)), list_extent)
+        # Accept multiple extents (list)
         extent1 = [50, 60, -40, 40]
         extent2 = [175, 180, -40, 40]
         list_extent = [extent1, extent2]
-        assert np.allclose(list(SExtent(list_extent)), list_extent)
+        assert np.allclose(list(SExtent(extent1, extent2)), list_extent)
+        # Accept multiple extents (tuple)
+        extent1 = (50, 60, -40, 40)
+        extent2 = (175, 180, -40, 40)
+        list_extent = [extent1, extent2]
+        assert np.allclose(list(SExtent(extent1, extent2)), list_extent)
+        # Accept multiple extents (np.array)
+        extent1 = np.array([0, 60, -40, 40])
+        extent2 = np.array([175, 180, -40, 40])
+        list_extent = [extent1, extent2]
+        assert np.allclose(list(SExtent(extent1, extent2)), list_extent)
+
+    def test_single_sextent_bad_topology(self):
+        """Test that raise error when the extents is a point or a line."""
+        # - Point extent
+        extent = [0, 0, 40, 40]
+        with pytest.raises(ValueError):
+            SExtent(extent)
+        # - Line extent
+        extent = [0, 10, 40, 40]
+        with pytest.raises(ValueError):
+            SExtent(extent)
+        extent = [0, 0, -40, 50]
+        with pytest.raises(ValueError):
+            SExtent(extent)
 
-    def test_sextent_bad_topology(self):
-        """Test that capture error when the extents composing SExtent overlaps."""
-        # Touching does not raise errors
+    def test_multple_touching_extents(self):
+        """Test that touching extents composing SExtent do not raise error."""
         extent1 = [0, 40, 0, 40]
         extent2 = [0, 40, -40, 0]
         _ = SExtent(extent1, extent2)
 
+    def test_multple_overlapping_extents(self):
+        """Test that raise error when the extents composing SExtent overlaps."""
         # Intersecting raise error
         extent1 = [0, 40, 0, 40]
         extent2 = [20, 60, 20, 60]
         with pytest.raises(ValueError):
             SExtent(extent1, extent2)
 
-        # TODO: Duplicate extent do not raise errors
+        # Duplicate extent raise errors
         extent1 = [0, 40, 0, 40]
-        extent2 = extent1
-        SExtent(extent1, extent2)
+        with pytest.raises(ValueError):
+            SExtent(extent1, extent1)
 
-        # TODO: Within extent do not raise errors
+        # Within extent raise errors
         extent1 = [0, 40, 0, 40]
         extent2 = [10, 20, 10, 20]
-        SExtent(extent1, extent2)
+        with pytest.raises(ValueError):
+            SExtent(extent1, extent2)
 
     def test_to_shapely(self):
         """Test shapely conversion."""
@@ -174,16 +202,22 @@ def test_is_global(self):
         sext = SExtent(extent)
         assert sext.is_global
 
-        # Is not global
+        # Is clearly not global
         extent = [-175, 180, -90, 90]
         sext = SExtent(extent)
         assert not sext.is_global
 
         # Is global, but with multiple extents
-        extent = [-180, 0, -90, 90]
-        extent1 = [0, 180, -90, 90]
-        sext = SExtent(extent, extent1)
-        assert not sext.is_global  # TODO IMPROVE !!!
+        extent1 = [-180, 0, -90, 90]
+        extent2 = [0, 180, -90, 90]
+        sext = SExtent(extent1, extent2)
+        assert sext.is_global
+
+        # Is not global, but polgon bounds ...
+        extent1 = [-180, 0, -90, 90]
+        extent2 = [0, 180, 0, 90]
+        sext = SExtent(extent1, extent2)
+        assert not sext.is_global
 
     def test_SExtent_single_not_intersect(self):
         """Check disjoint extents."""
@@ -496,3 +530,25 @@ def test_SExtent_multiple_equals(self):
         # Equal extents do not touches !
         assert not sext1.touches(sext2)
         assert not sext2.touches(sext1)
+
+    def test_SExtent_binary_predicates_bad_input(self):
+        extent = [160, 180, -40, 40]
+        sext = SExtent(extent)
+        # Disjoint
+        with pytest.raises(TypeError):
+            sext.disjoint("bad_dtype")
+        # Intersects
+        with pytest.raises(TypeError):
+            sext.intersects("bad_dtype")
+        # Within
+        with pytest.raises(TypeError):
+            sext.within("bad_dtype")
+        # Contains
+        with pytest.raises(TypeError):
+            sext.contains("bad_dtype")
+        # Touches
+        with pytest.raises(TypeError):
+            sext.touches("bad_dtype")
+        # Equals
+        with pytest.raises(TypeError):
+            sext.equals("bad_dtype")
