# Copyright Cartopy Contributors # # This file is part of Cartopy and is released under the LGPL license. # See COPYING and COPYING.LESSER in the root of the repository for full # licensing details. from __future__ import (absolute_import, division, print_function) import operator import warnings import matplotlib import matplotlib.collections as mcollections import matplotlib.ticker as mticker import matplotlib.transforms as mtrans import matplotlib.path as mpath import numpy as np import shapely.geometry as sgeom import cartopy from cartopy.crs import Projection, _RectangularProjection from cartopy.mpl.ticker import ( LongitudeLocator, LatitudeLocator, LongitudeFormatter, LatitudeFormatter) degree_locator = mticker.MaxNLocator(nbins=9, steps=[1, 1.5, 1.8, 2, 3, 6, 10]) classic_locator = mticker.MaxNLocator(nbins=9) classic_formatter = mticker.ScalarFormatter _DEGREE_SYMBOL = u'\u00B0' _X_INLINE_PROJS = ( cartopy.crs.InterruptedGoodeHomolosine, cartopy.crs.LambertConformal, cartopy.crs.Mollweide, cartopy.crs.Sinusoidal, cartopy.crs.RotatedPole, ) _POLAR_PROJS = ( cartopy.crs.NorthPolarStereo, cartopy.crs.SouthPolarStereo, cartopy.crs.Stereographic ) def _fix_lons(lons): """ Fix the given longitudes into the range ``[-180, 180]``. """ lons = np.array(lons, copy=False, ndmin=1) fixed_lons = ((lons + 180) % 360) - 180 # Make the positive 180s positive again. fixed_lons[(fixed_lons == -180) & (lons > 0)] *= -1 return fixed_lons def _lon_hemisphere(longitude): """Return the hemisphere (E, W or '' for 0) for the given longitude.""" longitude = _fix_lons(longitude) if longitude > 0: hemisphere = 'E' elif longitude < 0: hemisphere = 'W' else: hemisphere = '' return hemisphere def _lat_hemisphere(latitude): """Return the hemisphere (N, S or '' for 0) for the given latitude.""" if latitude > 0: hemisphere = 'N' elif latitude < 0: hemisphere = 'S' else: hemisphere = '' return hemisphere def _east_west_formatted(longitude, num_format='g'): fmt_string = u'{longitude:{num_format}}{degree}{hemisphere}' return fmt_string.format(longitude=abs(longitude), num_format=num_format, hemisphere=_lon_hemisphere(longitude), degree=_DEGREE_SYMBOL) def _north_south_formatted(latitude, num_format='g'): fmt_string = u'{latitude:{num_format}}{degree}{hemisphere}' return fmt_string.format(latitude=abs(latitude), num_format=num_format, hemisphere=_lat_hemisphere(latitude), degree=_DEGREE_SYMBOL) #: A formatter which turns longitude values into nice longitudes such as 110W LONGITUDE_FORMATTER = mticker.FuncFormatter(lambda v, pos: _east_west_formatted(v)) #: A formatter which turns longitude values into nice longitudes such as 45S LATITUDE_FORMATTER = mticker.FuncFormatter(lambda v, pos: _north_south_formatted(v)) class Gridliner(object): # NOTE: In future, one of these objects will be add-able to a GeoAxes (and # maybe even a plain old mpl axes) and it will call the "_draw_gridliner" # method on draw. This will enable automatic gridline resolution # determination on zoom/pan. def __init__(self, axes, crs, draw_labels=False, xlocator=None, ylocator=None, collection_kwargs=None, xformatter=None, yformatter=None, dms=False, x_inline=None, y_inline=None, auto_inline=True): """ Object used by :meth:`cartopy.mpl.geoaxes.GeoAxes.gridlines` to add gridlines and tick labels to a map. Parameters ---------- axes The :class:`cartopy.mpl.geoaxes.GeoAxes` object to be drawn on. crs The :class:`cartopy.crs.CRS` defining the coordinate system that the gridlines are drawn in. draw_labels: optional Toggle whether to draw labels. For finer control, attributes of :class:`Gridliner` may be modified individually. Defaults to False. xlocator: optional A :class:`matplotlib.ticker.Locator` instance which will be used to determine the locations of the gridlines in the x-coordinate of the given CRS. Defaults to None, which implies automatic locating of the gridlines. ylocator: optional A :class:`matplotlib.ticker.Locator` instance which will be used to determine the locations of the gridlines in the y-coordinate of the given CRS. Defaults to None, which implies automatic locating of the gridlines. xformatter: optional A :class:`matplotlib.ticker.Formatter` instance to format labels for x-coordinate gridlines. It defaults to None, which implies the use of a :class:`cartopy.mpl.ticker.LongitudeFormatter` initiated with the ``dms`` argument, if the crs is of :class:`~cartopy.crs.PlateCarree` type. yformatter: optional A :class:`matplotlib.ticker.Formatter` instance to format labels for y-coordinate gridlines. It defaults to None, which implies the use of a :class:`cartopy.mpl.ticker.LatitudeFormatter` initiated with the ``dms`` argument, if the crs is of :class:`~cartopy.crs.PlateCarree` type. collection_kwargs: optional Dictionary controlling line properties, passed to :class:`matplotlib.collections.Collection`. Defaults to None. dms: bool When default locators and formatters are used, ticks are able to stop on minutes and seconds if minutes is set to True, and not fraction of degrees. x_inline: optional Toggle whether the x labels drawn should be inline. y_inline: optional Toggle whether the y labels drawn should be inline. auto_inline: optional Set x_inline and y_inline automatically based on projection. Notes ----- The "x" and "y" labels for locators and formatters do not necessarily correspond to X and Y, but to the first and second coordinates of the specified CRS. For the common case of PlateCarree gridlines, these correspond to longitudes and latitudes. Depending on the projection used for the map, meridians and parallels can cross both the X axis and the Y axis. """ self.axes = axes #: The :class:`~matplotlib.ticker.Locator` to use for the x #: gridlines and labels. if xlocator is not None: if not isinstance(xlocator, mticker.Locator): xlocator = mticker.FixedLocator(xlocator) self.xlocator = xlocator elif isinstance(crs, cartopy.crs.PlateCarree): self.xlocator = LongitudeLocator(dms=dms) else: self.xlocator = classic_locator #: The :class:`~matplotlib.ticker.Locator` to use for the y #: gridlines and labels. if ylocator is not None: if not isinstance(ylocator, mticker.Locator): ylocator = mticker.FixedLocator(ylocator) self.ylocator = ylocator elif isinstance(crs, cartopy.crs.PlateCarree): self.ylocator = LatitudeLocator(dms=dms) else: self.ylocator = classic_locator if xformatter is None: if isinstance(crs, cartopy.crs.PlateCarree): xformatter = LongitudeFormatter(dms=dms) else: xformatter = classic_formatter() #: The :class:`~matplotlib.ticker.Formatter` to use for the lon labels. self.xformatter = xformatter if yformatter is None: if isinstance(crs, cartopy.crs.PlateCarree): yformatter = LatitudeFormatter(dms=dms) else: yformatter = classic_formatter() #: The :class:`~matplotlib.ticker.Formatter` to use for the lat labels. self.yformatter = yformatter #: Whether to draw labels on the top of the map. self.top_labels = draw_labels #: Whether to draw labels on the bottom of the map. self.bottom_labels = draw_labels #: Whether to draw labels on the left hand side of the map. self.left_labels = draw_labels #: Whether to draw labels on the right hand side of the map. self.right_labels = draw_labels if auto_inline: if isinstance(self.axes.projection, _X_INLINE_PROJS): self.x_inline = True self.y_inline = False elif isinstance(self.axes.projection, _POLAR_PROJS): self.x_inline = False self.y_inline = True else: self.x_inline = False self.y_inline = False # overwrite auto_inline if necessary if x_inline is not None: #: Whether to draw x labels inline self.x_inline = x_inline elif not auto_inline: self.x_inline = False if y_inline is not None: #: Whether to draw y labels inline self.y_inline = y_inline elif not auto_inline: self.y_inline = False #: Whether to draw the x gridlines. self.xlines = True #: Whether to draw the y gridlines. self.ylines = True #: A dictionary passed through to ``ax.text`` on x label creation #: for styling of the text labels. self.xlabel_style = {} #: A dictionary passed through to ``ax.text`` on y label creation #: for styling of the text labels. self.ylabel_style = {} #: The padding from the map edge to the x labels in points. self.xpadding = 5 #: The padding from the map edge to the y labels in points. self.ypadding = 5 #: Allow the rotation of labels. self.rotate_labels = True # Current transform self.crs = crs # if the user specifies tick labels at this point, check if they can # be drawn. The same check will take place at draw time in case # public attributes are changed after instantiation. if draw_labels and not (x_inline or y_inline or auto_inline): self._assert_can_draw_ticks() #: The number of interpolation points which are used to draw the #: gridlines. self.n_steps = 100 #: A dictionary passed through to #: ``matplotlib.collections.LineCollection`` on grid line creation. self.collection_kwargs = collection_kwargs #: The x gridlines which were created at draw time. self.xline_artists = [] #: The y gridlines which were created at draw time. self.yline_artists = [] # Plotted status self._plotted = False # Check visibility of labels at each draw event # (or once drawn, only at resize event ?) self.axes.figure.canvas.mpl_connect('draw_event', self._draw_event) @property def xlabels_top(self): warnings.warn('The .xlabels_top attribute is deprecated. Please ' 'use .top_labels to toggle visibility instead.') return self.top_labels @xlabels_top.setter def xlabels_top(self, value): warnings.warn('The .xlabels_top attribute is deprecated. Please ' 'use .top_labels to toggle visibility instead.') self.top_labels = value @property def xlabels_bottom(self): warnings.warn('The .xlabels_bottom attribute is deprecated. Please ' 'use .bottom_labels to toggle visibility instead.') return self.bottom_labels @xlabels_bottom.setter def xlabels_bottom(self, value): warnings.warn('The .xlabels_bottom attribute is deprecated. Please ' 'use .bottom_labels to toggle visibility instead.') self.bottom_labels = value @property def ylabels_left(self): warnings.warn('The .ylabels_left attribute is deprecated. Please ' 'use .left_labels to toggle visibility instead.') return self.left_labels @ylabels_left.setter def ylabels_left(self, value): warnings.warn('The .ylabels_left attribute is deprecated. Please ' 'use .left_labels to toggle visibility instead.') self.left_labels = value @property def ylabels_right(self): warnings.warn('The .ylabels_right attribute is deprecated. Please ' 'use .right_labels to toggle visibility instead.') return self.right_labels @ylabels_right.setter def ylabels_right(self, value): warnings.warn('The .ylabels_right attribute is deprecated. Please ' 'use .right_labels to toggle visibility instead.') self.right_labels = value def _draw_event(self, event): if self.has_labels(): self._update_labels_visibility(event.renderer) def has_labels(self): return hasattr(self, '_labels') and self._labels @property def label_artists(self): if self.has_labels(): return self._labels return [] def _crs_transform(self): """ Get the drawing transform for our gridlines. Note ---- The drawing transform depends on the transform of our 'axes', so it may change dynamically. """ transform = self.crs if not isinstance(transform, mtrans.Transform): transform = transform._as_mpl_transform(self.axes) return transform @staticmethod def _round(x, base=5): if np.isnan(base): base = 5 return int(base * round(float(x) / base)) def _find_midpoints(self, lim, ticks): # Find the center point between each lat gridline. if len(ticks) > 1: cent = np.diff(ticks).mean() / 2 else: cent = np.nan if isinstance(self.axes.projection, _POLAR_PROJS): lq = 90 uq = 90 else: lq = 25 uq = 75 midpoints = (self._round(np.percentile(lim, lq), cent), self._round(np.percentile(lim, uq), cent)) return midpoints def _draw_gridliner(self, nx=None, ny=None, renderer=None): """Create Artists for all visible elements and add to our Axes.""" # Check status if self._plotted: return self._plotted = True # Inits lon_lim, lat_lim = self._axes_domain(nx=nx, ny=ny) transform = self._crs_transform() rc_params = matplotlib.rcParams n_steps = self.n_steps crs = self.crs # Get nice ticks within crs domain lon_ticks = self.xlocator.tick_values(lon_lim[0], lon_lim[1]) lat_ticks = self.ylocator.tick_values(lat_lim[0], lat_lim[1]) lon_ticks = [value for value in lon_ticks if value >= max(lon_lim[0], crs.x_limits[0]) and value <= min(lon_lim[1], crs.x_limits[1])] lat_ticks = [value for value in lat_ticks if value >= max(lat_lim[0], crs.y_limits[0]) and value <= min(lat_lim[1], crs.y_limits[1])] ##################### # Gridlines drawing # ##################### collection_kwargs = self.collection_kwargs if collection_kwargs is None: collection_kwargs = {} collection_kwargs = collection_kwargs.copy() collection_kwargs['transform'] = transform # XXX doesn't gracefully handle lw vs linewidth aliases... collection_kwargs.setdefault('color', rc_params['grid.color']) collection_kwargs.setdefault('linestyle', rc_params['grid.linestyle']) collection_kwargs.setdefault('linewidth', rc_params['grid.linewidth']) # Meridians lat_min, lat_max = lat_lim if lat_ticks: lat_min = min(lat_min, min(lat_ticks)) lat_max = max(lat_max, max(lat_ticks)) lon_lines = np.empty((len(lon_ticks), n_steps, 2)) lon_lines[:, :, 0] = np.array(lon_ticks)[:, np.newaxis] lon_lines[:, :, 1] = np.linspace(lat_min, lat_max, n_steps)[np.newaxis, :] if self.xlines: nx = len(lon_lines) + 1 # XXX this bit is cartopy specific. (for circular longitudes) # Purpose: omit plotting the last x line, # as it may overlap the first. if (isinstance(crs, Projection) and isinstance(crs, _RectangularProjection) and abs(np.diff(lon_lim)) == abs(np.diff(crs.x_limits))): nx -= 1 lon_lc = mcollections.LineCollection(lon_lines, **collection_kwargs) self.xline_artists.append(lon_lc) self.axes.add_collection(lon_lc, autolim=False) # Parallels lon_min, lon_max = lon_lim if lon_ticks: lon_min = min(lon_min, min(lon_ticks)) lon_max = max(lon_max, max(lon_ticks)) lat_lines = np.empty((len(lat_ticks), n_steps, 2)) lat_lines[:, :, 0] = np.linspace(lon_min, lon_max, n_steps)[np.newaxis, :] lat_lines[:, :, 1] = np.array(lat_ticks)[:, np.newaxis] if self.ylines: lat_lc = mcollections.LineCollection(lat_lines, **collection_kwargs) self.yline_artists.append(lat_lc) self.axes.add_collection(lat_lc, autolim=False) ################# # Label drawing # ################# self.bottom_label_artists = [] self.top_label_artists = [] self.left_label_artists = [] self.right_label_artists = [] if not (self.left_labels or self.right_labels or self.bottom_labels or self.top_labels): return self._assert_can_draw_ticks() # Get the real map boundaries map_boundary_vertices = self.axes.patch.get_path().vertices map_boundary = sgeom.Polygon(map_boundary_vertices) self._labels = [] if self.x_inline: y_midpoints = self._find_midpoints(lat_lim, lat_ticks) if self.y_inline: x_midpoints = self._find_midpoints(lon_lim, lon_ticks) for lonlat, lines, line_ticks, formatter, label_style in ( ('lon', lon_lines, lon_ticks, self.xformatter, self.xlabel_style), ('lat', lat_lines, lat_ticks, self.yformatter, self.ylabel_style)): formatter.set_locs(line_ticks) for line, tick_value in zip(lines, line_ticks): # Intersection of line with map boundary line = self.axes.projection.transform_points( crs, line[:, 0], line[:, 1])[:, :2] infs = np.isinf(line).any(axis=1) line = line.compress(~infs, axis=0) if line.size == 0: continue line = sgeom.LineString(line) if line.intersects(map_boundary): intersection = line.intersection(map_boundary) del line if intersection.is_empty: continue if isinstance(intersection, sgeom.MultiPoint): if len(intersection) < 2: continue tails = [[(pt.x, pt.y) for pt in intersection[:2]]] heads = [[(pt.x, pt.y) for pt in intersection[-1:-3:-1]]] elif isinstance(intersection, (sgeom.LineString, sgeom.MultiLineString)): if isinstance(intersection, sgeom.LineString): intersection = [intersection] elif len(intersection) > 4: # Gridline and map boundary are parallel # and they intersect themselves too much # it results in a multiline string # that must be converted to a single linestring. # This is an empirical workaround for a problem # that can probably be solved in a cleaner way. xy = np.append(intersection[0], intersection[-1], axis=0) intersection = [sgeom.LineString(xy)] tails = [] heads = [] for inter in intersection: if len(inter.coords) < 2: continue tails.append(inter.coords[:2]) heads.append(inter.coords[-1:-3:-1]) if not tails: continue elif isinstance(intersection, sgeom.collection.GeometryCollection): # This is a collection of Point and LineString that # represent the same gridline. # We only consider the first geometries, merge their # coordinates and keep first two points to get only one # tail ... xy = [] for geom in intersection.geoms: for coord in geom.coords: xy.append(coord) if len(xy) == 2: break if len(xy) == 2: break tails = [xy] # ... and the last geometries, merge their coordinates # and keep last two points to get only one head. xy = [] for geom in reversed(intersection.geoms): for coord in reversed(geom.coords): xy.append(coord) if len(xy) == 2: break if len(xy) == 2: break heads = [xy] else: warnings.warn( 'Unsupported intersection geometry for gridline ' 'labels: ' + intersection.__class__.__name__) continue del intersection # Loop on head and tail and plot label by extrapolation for tail, head in zip(tails, heads): for i, (pt0, pt1) in enumerate([tail, head]): kw, angle, loc = self._segment_to_text_specs( pt0, pt1, lonlat) if not getattr(self, loc+'_labels'): continue kw.update(label_style, bbox={'pad': 0, 'visible': False}) text = formatter(tick_value) if self.y_inline and lonlat == 'lat': # 180 degrees isn't formatted with a # suffix and adds confusion if it's inline if abs(tick_value) == 180: continue x = x_midpoints[i] y = tick_value kw.update(clip_on=True) y_set = True else: x = pt0[0] y_set = False if self.x_inline and lonlat == 'lon': if abs(tick_value) == 180: continue x = tick_value y = y_midpoints[i] kw.update(clip_on=True) elif not y_set: y = pt0[1] tt = self.axes.text(x, y, text, **kw) tt._angle = angle priority = (((lonlat == 'lon') and loc in ('bottom', 'top')) or ((lonlat == 'lat') and loc in ('left', 'right'))) self._labels.append((lonlat, priority, tt)) getattr(self, loc + '_label_artists').append(tt) # Sort labels if self._labels: self._labels.sort(key=operator.itemgetter(0), reverse=True) self._update_labels_visibility(renderer) def _segment_to_text_specs(self, pt0, pt1, lonlat): """Get appropriate kwargs for a label from lon or lat line segment""" x0, y0 = pt0 x1, y1 = pt1 angle = np.arctan2(y0-y1, x0-x1) * 180 / np.pi kw, loc = self._segment_angle_to_text_specs(angle, lonlat) return kw, angle, loc def _text_angle_to_specs_(self, angle, lonlat): """Get specs for a rotated label from its angle in degrees""" angle %= 360 if angle > 180: angle -= 360 if ((self.x_inline and lonlat == 'lon') or (self.y_inline and lonlat == 'lat')): kw = {'rotation': 0, 'rotation_mode': 'anchor', 'ha': 'center', 'va': 'center'} loc = 'bottom' return kw, loc # Default options kw = {'rotation': angle, 'rotation_mode': 'anchor'} # Options that depend in which quarter the angle falls if abs(angle) <= 45: loc = 'right' kw.update(ha='left', va='center') elif abs(angle) >= 135: loc = 'left' kw.update(ha='right', va='center') kw['rotation'] -= np.sign(angle) * 180 elif angle > 45: loc = 'top' kw.update(ha='center', va='bottom', rotation=angle-90) else: loc = 'bottom' kw.update(ha='center', va='top', rotation=angle+90) return kw, loc def _segment_angle_to_text_specs(self, angle, lonlat): """Get appropriate kwargs for a given text angle""" kw, loc = self._text_angle_to_specs_(angle, lonlat) if not self.rotate_labels: angle = {'top': 90., 'right': 0., 'bottom': -90., 'left': 180.}[loc] del kw['rotation'] if ((self.x_inline and lonlat == 'lon') or (self.y_inline and lonlat == 'lat')): kw.update(transform=cartopy.crs.PlateCarree()) else: xpadding = (self.xpadding if self.xpadding is not None else matplotlib.rc_params['xtick.major.pad']) ypadding = (self.ypadding if self.ypadding is not None else matplotlib.rc_params['ytick.major.pad']) dx = ypadding * np.cos(angle * np.pi / 180) dy = xpadding * np.sin(angle * np.pi / 180) transform = mtrans.offset_copy( self.axes.transData, self.axes.figure, x=dx, y=dy, units='dots') kw.update(transform=transform) return kw, loc def _update_labels_visibility(self, renderer): """Update the visibility of each plotted label The following rules apply: - Labels are plotted and checked by order of priority, with a high priority for longitude labels at the bottom and top of the map, and the reverse for latitude labels. - A label must not overlap another label marked as visible. - A label must not overlap the map boundary. - When a label is about to be hidden, other angles are tried in the absolute given limit of max_delta_angle by increments of delta_angle of difference from the original angle. """ if renderer is None or not self._labels: return paths = [] outline_path = None delta_angle = 22.5 max_delta_angle = 45 axes_children = self.axes.get_children() def remove_path_dupes(path): """ Remove duplicate points in a path (zero-length segments). This is necessary only for Matplotlib 3.1.0 -- 3.1.2, because Path.intersects_path incorrectly returns True for any paths with such segments. """ segment_length = np.diff(path.vertices, axis=0) mask = np.logical_or.reduce(segment_length != 0, axis=1) mask = np.append(mask, True) path = mpath.Path(np.compress(mask, path.vertices, axis=0), np.compress(mask, path.codes, axis=0)) return path for lonlat, priority, artist in self._labels: if artist not in axes_children: warnings.warn('The labels of this gridliner do not belong to ' 'the gridliner axes') orig_specs = {'rotation': artist.get_rotation(), 'ha': artist.get_ha(), 'va': artist.get_va()} # Compute angles to try angles = [None] for abs_delta_angle in np.arange(delta_angle, max_delta_angle+1, delta_angle): angles.append(artist._angle + abs_delta_angle) angles.append(artist._angle - abs_delta_angle) # Loop on angles until it works for angle in angles: if ((self.x_inline and lonlat == 'lon') or (self.y_inline and lonlat == 'lat')): angle = 0 if angle is not None: specs, _ = self._segment_angle_to_text_specs(angle, lonlat) artist.update(specs) artist.update_bbox_position_size(renderer) this_patch = artist.get_bbox_patch() this_path = this_patch.get_path().transformed( this_patch.get_transform()) if '3.1.0' <= matplotlib.__version__ <= '3.1.2': this_path = remove_path_dupes(this_path) center = artist.get_transform().transform_point( artist.get_position()) visible = False for path in paths: # Check it does not overlap another label if this_path.intersects_path(path): break else: # Finally check that it does not overlap the map if outline_path is None: outline_path = (self.axes.patch.get_path() .transformed(self.axes.transData)) if '3.1.0' <= matplotlib.__version__ <= '3.1.2': outline_path = remove_path_dupes(outline_path) # Inline must be within the map. if ((lonlat == 'lon' and self.x_inline) or (lonlat == 'lat' and self.y_inline)): # TODO: When Matplotlib clip path works on text, this # clipping can be left to it. if outline_path.contains_point(center): visible = True # Non-inline must not run through the outline. elif not outline_path.intersects_path(this_path): visible = True # Good if visible: break if ((self.x_inline and lonlat == 'lon') or (self.y_inline and lonlat == 'lat')): break # Action artist.set_visible(visible) if not visible: artist.update(orig_specs) else: paths.append(this_path) def _assert_can_draw_ticks(self): """ Check to see if ticks can be drawn. Either returns True or raises an exception. """ # Check labelling is supported, currently a limited set of options. if not isinstance(self.crs, cartopy.crs.PlateCarree): raise TypeError('Cannot label {crs.__class__.__name__} gridlines.' ' Only PlateCarree gridlines are currently ' 'supported.'.format(crs=self.crs)) return True def _axes_domain(self, nx=None, ny=None): """Return lon_range, lat_range""" DEBUG = False transform = self._crs_transform() ax_transform = self.axes.transAxes desired_trans = ax_transform - transform nx = nx or 100 ny = ny or 100 x = np.linspace(1e-9, 1 - 1e-9, nx) y = np.linspace(1e-9, 1 - 1e-9, ny) x, y = np.meshgrid(x, y) coords = np.column_stack((x.ravel(), y.ravel())) in_data = desired_trans.transform(coords) ax_to_bkg_patch = self.axes.transAxes - self.axes.patch.get_transform() # convert the coordinates of the data to the background patches # coordinates background_coord = ax_to_bkg_patch.transform(coords) ok = self.axes.patch.get_path().contains_points(background_coord) if DEBUG: import matplotlib.pyplot as plt plt.plot(coords[ok, 0], coords[ok, 1], 'or', clip_on=False, transform=ax_transform) plt.plot(coords[~ok, 0], coords[~ok, 1], 'ob', clip_on=False, transform=ax_transform) inside = in_data[ok, :] # If there were no data points in the axes we just use the x and y # range of the projection. if inside.size == 0: lon_range = self.crs.x_limits lat_range = self.crs.y_limits else: # np.isfinite must be used to prevent np.inf values that # not filtered by np.nanmax for some projections lat_max = np.compress(np.isfinite(inside[:, 1]), inside[:, 1]) if lat_max.size == 0: lon_range = self.crs.x_limits lat_range = self.crs.y_limits else: lat_max = lat_max.max() lon_range = np.nanmin(inside[:, 0]), np.nanmax(inside[:, 0]) lat_range = np.nanmin(inside[:, 1]), lat_max # XXX Cartopy specific thing. Perhaps make this bit a specialisation # in a subclass... crs = self.crs if isinstance(crs, Projection): lon_range = np.clip(lon_range, *crs.x_limits) lat_range = np.clip(lat_range, *crs.y_limits) # if the limit is >90% of the full x limit, then just use the full # x limit (this makes circular handling better) prct = np.abs(np.diff(lon_range) / np.diff(crs.x_limits)) if prct > 0.9: lon_range = crs.x_limits return lon_range, lat_range