Update and add more tests for blockplotting 2d coords

Author: lbdreyer

lib/iris/coords.py

@@ -143,74 +143,97 @@ def __new__(cls, name_or_coord, minimum, maximum,
                                       'groupby_point, groupby_slice')
 
 
-def _discontiguity_in_2d_bounds(bds, abs_tol=1e-4):
+def _discontiguity_in_2d_bounds(bds, atol=1e-4):
     """
-    Check bounds of a 2-dimensional coordinate are contiguous
+    Checks that the bounds of a 2-dimensional coordinate are contiguous.
+
     Args:
-        bds: Array of bounds of shape (X,Y,4)
-        abs_tol: tolerance
+    * bds: (array)
+        Bounds array of shape (X,Y,4).
+    * atol: (float)
+        Absolute tolerance that is used when checking contiguity. Defaults to
+        1e-4.
 
     Returns:
-        Bool, if there are no discontinuities
-        absolute difference along the x axis
-        absolute difference along the y axis
+    * all_equal: (boolean)
+        True if there are no discontiguities.
+    * diffs_along_x: (array or None)
+        Either an array of the absolute differences along the x-axis, of the
+        shape (X,Y-1) or None if the input bounds has the shape (1,Y,4).
+    * diffs_along_y: (array or None)
+        Either an array of the absolute differences along the y-axis, of the
+        shape (X-1,Y) or None if the input bounds has the shape (X,1,4).
 
     """
     # Check bds has the shape (ny, nx, 4)
-    if not bds.ndim == 3 and bds.shape[2] == 4:
-        raise ValueError('2D coordinates must have 4 bounds per point '
-                         'for 2D coordinate plotting')
+    if not (bds.ndim == 3 and bds.shape[-1] == 4):
+        raise ValueError('Bounds for 2D coordinates must be 3-dimensional and '
+                         'have 4 bounds per point.')
 
     # Check ordering:
     #         i    i+1
     #    j    @0    @1
     #  j+1    @3    @2
-    def mod360_diff(x1, x2):
-        diff = x1 - x2
+    def mod360_diff(upper_bounds, lower_bounds):
+        diff = upper_bounds - lower_bounds
         diff = (diff + 360.0 + 180.0) % 360.0 - 180.0
         return diff
 
-    # Compare cell with the cell next to it (i+1)
-    diffs_along_x = mod360_diff(bds[:, :-1, 1], bds[:, 1:, 0])
-    # Compare cell with the cell above it (j+1)
-    diffs_along_y = mod360_diff(bds[:-1, :, 3], bds[1:, :, 0])
+    def diffs_below_tolerance(diffs_along_axis):
+        return np.all(np.abs(diffs_along_axis) < atol)
 
-    def eq_diffs(x1):
-        return np.all(np.abs(x1) < abs_tol)
+    # Compare cell with the cell next to it (i+1)
+    if bds.shape[0] > 1:
+        diffs_along_x = np.abs(mod360_diff(bds[:, :-1, 1], bds[:, 1:, 0]))
+        match_y0_x1 = diffs_below_tolerance(diffs_along_x)
+    else:
+        diffs_along_x = None
+        match_y0_x1 = True
 
-    match_y0_x1 = eq_diffs(diffs_along_x)
-    match_y1_x0 = eq_diffs(diffs_along_y)
+    # Compare cell with the cell above it (j+1)
+    if bds.shape[1] > 1:
+        diffs_along_y = np.abs(mod360_diff(bds[:-1, :, 3], bds[1:, :, 0]))
+        match_y1_x0 = diffs_below_tolerance(diffs_along_y)
+    else:
+        diffs_along_y = None
+        match_y1_x0 = True
 
     all_eq = match_y0_x1 and match_y1_x0
 
-    return all_eq, np.abs(diffs_along_x), np.abs(diffs_along_y)
+    return all_eq, diffs_along_x, diffs_along_y
 
 
 def _get_2d_coord_bound_grid(bds):
     """
-    Function used that takes a bounds array for a 2-D coordinate variable with
-    4 sides and returns the bounds grid.
+    Creates a grid using the bounds of a 2D coordinate with 4 sided cells.
 
-    Cf standards requires the four vertices of the cell to be traversed
-    anti-clockwise if the coordinates are defined in a right handed coordinate
-    system.
+    Assumes that the four vertices of the cells are in an anti-clockwise order
+    (bottom-left, bottom-right, top-right, top-left).
 
-    selects the zeroth vertex of each cell and then adds the column the first
-    vertex at the end. For the top row it uses the thirs vertex, with the
-    second added on to the end.
+    Selects the zeroth vertex of each cell. A final column is added, which
+    contains the first vertex of the cells in the final column. A final row
+    is added, which contains the third vertex of all the cells in the final
+    row, except for in the final column where it uses the second vertex.
     e.g.
     # 0-0-0-0-1
     # 0-0-0-0-1
     # 3-3-3-3-2
 
 
     Args:
-        bounds: array of shape (X,Y,4)
+    * bounds: (array)
+        Coordinate bounds array of shape (X,Y,4)
 
     Returns:
-        array of shape (X+1, Y+1)
+    * grid: (array)
+        Grid of shape (X+1, Y+1)
 
     """
+    # Check bds has the shape (ny, nx, 4)
+    if not (bds.ndim == 3 and bds.shape[-1] == 4):
+        raise ValueError('Bounds for 2D coordinates must be 3-dimensional and '
+                         'have 4 bounds per point.')
+
     bds_shape = bds.shape
     result = np.zeros((bds_shape[0] + 1, bds_shape[1] + 1))
 
@@ -1029,7 +1052,7 @@ def cells(self):
         """
         return _CellIterator(self)
 
-    def _sanity_check_contiguous(self):
+    def _sanity_check_bounds(self):
         if self.ndim == 1:
             if self.nbounds != 2:
                 raise ValueError('Invalid operation for {!r}, with {} bounds. '
@@ -1043,9 +1066,9 @@ def _sanity_check_contiguous(self):
                                  'coordinates with 4 bounds.'.format
                                  (self.name(), self.nbounds))
         else:
-            raise ValueError('Invalid operation for {!r}. Contiguous bounds '
-                             'are not defined for coordinates with more than '
-                             '2 dimensions.'.format(self.name()))
+            raise ValueError('Invalid operation for {!r}. Not supported for '
+                             'bounds with more than 2 dimensions.'.format
+                             (self.name()))
 
     def is_contiguous(self, rtol=1e-05, atol=1e-08):
         """
@@ -1064,28 +1087,25 @@ def is_contiguous(self, rtol=1e-05, atol=1e-08):
 
         """
         if self.has_bounds():
-            self._sanity_check_contiguous()
+            self._sanity_check_bounds()
             if self.ndim == 1:
                 contiguous = np.allclose(self.bounds[1:, 0],
                                          self.bounds[:-1, 1],
                                          rtol=rtol, atol=atol)
             elif self.ndim == 2:
-                contiguous, _, _ = _discontiguity_in_2d_bounds(self.bounds,
-                                                               abs_tol=atol)
+
+                contiguous, _, _ = _discontiguity_in_2d_bounds(
+                    self.bounds, atol=atol)
         else:
             contiguous = False
         return contiguous
 
     def contiguous_bounds(self):
         """
         Returns the N+1 bound values for a contiguous bounded 1D coordinate
-        of length N.
-
-        Returns the (N+1, M+1) bound values for a contiguous bounded 2D
+        of length N, or the (N+1, M+1) bound values for a contiguous bounded 2D
         coordinate of shape (N, M).
 
-        Assumes input is contiguous.
-
         .. note::
 
             If the coordinate does not have bounds, this method will
@@ -1097,7 +1117,10 @@ def contiguous_bounds(self):
                           'contiguous bounds.'.format(self.name()))
             bounds = self._guess_bounds()
         else:
-            self._sanity_check_contiguous()
+            if not self.is_contiguous():
+                raise ValueError('Invalid operation. Bounds of coord {!r} '
+                                 'are not contiguous.'.format(self.name()))
+
             bounds = self.bounds
 
         if self.ndim == 1:

lib/iris/plot.py

@@ -102,10 +102,20 @@ def get_span(coord):
             raise ValueError(msg.format(coord.name()))
         if mode == iris.coords.BOUND_MODE and len(span) not in [1, 2]:
             raise ValueError('The coordinate {!r} has {} dimensions.'
-                             'Cell-based plotting is only supporting for'
+                             'Cell-based plotting is only supported for'
                              'coordinates with one or two dimensions.'
                              .format(coord.name()), len(span))
 
+    # Check the coords have the same number of dimensions.
+    if ndims == 2:
+        if not (len(spans[0]) == len(spans[1])):
+            raise ValueError('The coordinate {!r} has {} dimensions and the '
+                             'coordinate {!r} has {} dimensions. Cell-based '
+                             'plotting is only supported for coordinates with '
+                             'the same number of dimensions.'
+                             .format(coords[0].name(), spans[0],
+                                     coords[1].name(), spans[1]))
+
     # Check the combination of coordinates spans enough (ndims) data
     # dimensions.
     total_span = set().union(*spans)
@@ -273,10 +283,11 @@ def _invert_yaxis(v_coord, axes=None):
 
 def _check_contiguity_and_bounds(coord, data, abs_tol=1e-4, transpose=False):
     """
-    Check that the discontinuous bounds occur where the data is masked.
+    Checks that any discontiguity in the bounds of the coordinate only occur
+    where the data is masked.
 
-    If discontinuity occurs but data is masked, raise warning
-    If discontinuity occurs and data is NOT masked, raise error
+    If discontiguity occurs but data is masked, raise warning
+    If discontiguity occurs and data is NOT masked, raise error
 
     Args:
         coords:
@@ -293,7 +304,7 @@ def _check_contiguity_and_bounds(coord, data, abs_tol=1e-4, transpose=False):
     bounds = coord.bounds
 
     both_dirs_contiguous, diffs_along_x, diffs_along_y = \
-        iris.coords._discontiguity_in_2d_bounds(bounds, abs_tol=abs_tol)
+        iris.coords._discontiguity_in_2d_bounds(bounds, atol=abs_tol)
 
     if not both_dirs_contiguous:
 
@@ -333,17 +344,13 @@ def _draw_2d_from_bounds(draw_method_name, cube, *args, **kwargs):
     else:
         plot_defn = _get_plot_defn(cube, mode, ndims=2)
 
-    twodim_contig_atol = kwargs.pop('two_dim_coord_contiguity_atol',
-                                    1e-4)
     for coord in plot_defn.coords:
         if hasattr(coord, 'has_bounds'):
             if coord.ndim == 2 and coord.has_bounds():
                 try:
-                    _check_contiguity_and_bounds(coord, data=cube.data,
-                                                 abs_tol=twodim_contig_atol)
+                    _check_contiguity_and_bounds(coord, data=cube.data)
                 except ValueError:
                     if _check_contiguity_and_bounds(coord, data=cube.data,
-                                                    abs_tol=twodim_contig_atol,
                                                     transpose=True) is True:
                         plot_defn.transpose = True
 
@@ -1117,10 +1124,6 @@ def pcolor(cube, *args, **kwargs):
     * axes: the :class:`matplotlib.axes.Axes` to use for drawing.
         Defaults to the current axes if none provided.
 
-    * two_dim_coord_contiguity_atol: absolute tolerance when checking for
-        contiguity between cells in a two dimensional coordinate.
-
-
 
     See :func:`matplotlib.pyplot.pcolor` for details of other valid
     keyword arguments.
@@ -1152,9 +1155,6 @@ def pcolormesh(cube, *args, **kwargs):
     * axes: the :class:`matplotlib.axes.Axes` to use for drawing.
         Defaults to the current axes if none provided.
 
-    * two_dim_coord_contiguity_atol: absolute tolerance when checking for
-        contiguity between cells in a two dimensional coordinate.
-
     See :func:`matplotlib.pyplot.pcolormesh` for details of other
     valid keyword arguments.
 

lib/iris/tests/integration/plot/test_plot_2d_coords.py

@@ -0,0 +1,54 @@
+# (C) British Crown Copyright 2017, Met Office
+#
+# This file is part of Iris.
+#
+# Iris is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Iris is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Iris.  If not, see <http://www.gnu.org/licenses/>.
+"""
+Test plots with two dimensional coordinates.
+
+"""
+
+from __future__ import (absolute_import, division, print_function)
+from six.moves import (filter, input, map, range, zip)  # noqa
+
+# import iris tests first so that some things can be initialised before
+# importing anything else
+import iris.tests as tests
+
+import iris
+
+# Run tests in no graphics mode if matplotlib is not available.
+if tests.MPL_AVAILABLE:
+    import matplotlib.pyplot as plt
+    import iris.quickplot as qplt
+
+
+@tests.skip_data
+def simple_cube():
+    path = tests.get_data_path(('NetCDF', 'ORCA2', 'votemper.nc'))
+    cube = iris.load_cube(path)
+    return cube[0, 0]
+
+
+@tests.skip_plot
+@tests.skip_data
+class Test(tests.GraphicsTest):
+    def test_2d_coord_bounds(self):
+        cube = simple_cube()
+        qplt.pcolormesh(cube)
+        self.check_graphic()
+
+
+if __name__ == "__main__":
+    tests.main()