| | import numpy as np |
| |
|
| | from matplotlib import _docstring |
| | from matplotlib.contour import ContourSet |
| | from matplotlib.tri._triangulation import Triangulation |
| |
|
| |
|
| | @_docstring.dedent_interpd |
| | class TriContourSet(ContourSet): |
| | """ |
| | Create and store a set of contour lines or filled regions for |
| | a triangular grid. |
| | |
| | This class is typically not instantiated directly by the user but by |
| | `~.Axes.tricontour` and `~.Axes.tricontourf`. |
| | |
| | %(contour_set_attributes)s |
| | """ |
| | def __init__(self, ax, *args, **kwargs): |
| | """ |
| | Draw triangular grid contour lines or filled regions, |
| | depending on whether keyword arg *filled* is False |
| | (default) or True. |
| | |
| | The first argument of the initializer must be an `~.axes.Axes` |
| | object. The remaining arguments and keyword arguments |
| | are described in the docstring of `~.Axes.tricontour`. |
| | """ |
| | super().__init__(ax, *args, **kwargs) |
| |
|
| | def _process_args(self, *args, **kwargs): |
| | """ |
| | Process args and kwargs. |
| | """ |
| | if isinstance(args[0], TriContourSet): |
| | C = args[0]._contour_generator |
| | if self.levels is None: |
| | self.levels = args[0].levels |
| | self.zmin = args[0].zmin |
| | self.zmax = args[0].zmax |
| | self._mins = args[0]._mins |
| | self._maxs = args[0]._maxs |
| | else: |
| | from matplotlib import _tri |
| | tri, z = self._contour_args(args, kwargs) |
| | C = _tri.TriContourGenerator(tri.get_cpp_triangulation(), z) |
| | self._mins = [tri.x.min(), tri.y.min()] |
| | self._maxs = [tri.x.max(), tri.y.max()] |
| |
|
| | self._contour_generator = C |
| | return kwargs |
| |
|
| | def _contour_args(self, args, kwargs): |
| | tri, args, kwargs = Triangulation.get_from_args_and_kwargs(*args, |
| | **kwargs) |
| | z, *args = args |
| | z = np.ma.asarray(z) |
| | if z.shape != tri.x.shape: |
| | raise ValueError('z array must have same length as triangulation x' |
| | ' and y arrays') |
| |
|
| | |
| | |
| | z_check = z[np.unique(tri.get_masked_triangles())] |
| | if np.ma.is_masked(z_check): |
| | raise ValueError('z must not contain masked points within the ' |
| | 'triangulation') |
| | if not np.isfinite(z_check).all(): |
| | raise ValueError('z array must not contain non-finite values ' |
| | 'within the triangulation') |
| |
|
| | z = np.ma.masked_invalid(z, copy=False) |
| | self.zmax = float(z_check.max()) |
| | self.zmin = float(z_check.min()) |
| | if self.logscale and self.zmin <= 0: |
| | func = 'contourf' if self.filled else 'contour' |
| | raise ValueError(f'Cannot {func} log of negative values.') |
| | self._process_contour_level_args(args, z.dtype) |
| | return (tri, z) |
| |
|
| |
|
| | _docstring.interpd.update(_tricontour_doc=""" |
| | Draw contour %%(type)s on an unstructured triangular grid. |
| | |
| | Call signatures:: |
| | |
| | %%(func)s(triangulation, z, [levels], ...) |
| | %%(func)s(x, y, z, [levels], *, [triangles=triangles], [mask=mask], ...) |
| | |
| | The triangular grid can be specified either by passing a `.Triangulation` |
| | object as the first parameter, or by passing the points *x*, *y* and |
| | optionally the *triangles* and a *mask*. See `.Triangulation` for an |
| | explanation of these parameters. If neither of *triangulation* or |
| | *triangles* are given, the triangulation is calculated on the fly. |
| | |
| | It is possible to pass *triangles* positionally, i.e. |
| | ``%%(func)s(x, y, triangles, z, ...)``. However, this is discouraged. For more |
| | clarity, pass *triangles* via keyword argument. |
| | |
| | Parameters |
| | ---------- |
| | triangulation : `.Triangulation`, optional |
| | An already created triangular grid. |
| | |
| | x, y, triangles, mask |
| | Parameters defining the triangular grid. See `.Triangulation`. |
| | This is mutually exclusive with specifying *triangulation*. |
| | |
| | z : array-like |
| | The height values over which the contour is drawn. Color-mapping is |
| | controlled by *cmap*, *norm*, *vmin*, and *vmax*. |
| | |
| | .. note:: |
| | All values in *z* must be finite. Hence, nan and inf values must |
| | either be removed or `~.Triangulation.set_mask` be used. |
| | |
| | levels : int or array-like, optional |
| | Determines the number and positions of the contour lines / regions. |
| | |
| | If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to |
| | automatically choose no more than *n+1* "nice" contour levels between |
| | between minimum and maximum numeric values of *Z*. |
| | |
| | If array-like, draw contour lines at the specified levels. The values must |
| | be in increasing order. |
| | |
| | Returns |
| | ------- |
| | `~matplotlib.tri.TriContourSet` |
| | |
| | Other Parameters |
| | ---------------- |
| | colors : color string or sequence of colors, optional |
| | The colors of the levels, i.e., the contour %%(type)s. |
| | |
| | The sequence is cycled for the levels in ascending order. If the sequence |
| | is shorter than the number of levels, it is repeated. |
| | |
| | As a shortcut, single color strings may be used in place of one-element |
| | lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the |
| | same color. This shortcut does only work for color strings, not for other |
| | ways of specifying colors. |
| | |
| | By default (value *None*), the colormap specified by *cmap* will be used. |
| | |
| | alpha : float, default: 1 |
| | The alpha blending value, between 0 (transparent) and 1 (opaque). |
| | |
| | %(cmap_doc)s |
| | |
| | This parameter is ignored if *colors* is set. |
| | |
| | %(norm_doc)s |
| | |
| | This parameter is ignored if *colors* is set. |
| | |
| | %(vmin_vmax_doc)s |
| | |
| | If *vmin* or *vmax* are not given, the default color scaling is based on |
| | *levels*. |
| | |
| | This parameter is ignored if *colors* is set. |
| | |
| | origin : {*None*, 'upper', 'lower', 'image'}, default: None |
| | Determines the orientation and exact position of *z* by specifying the |
| | position of ``z[0, 0]``. This is only relevant, if *X*, *Y* are not given. |
| | |
| | - *None*: ``z[0, 0]`` is at X=0, Y=0 in the lower left corner. |
| | - 'lower': ``z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner. |
| | - 'upper': ``z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner. |
| | - 'image': Use the value from :rc:`image.origin`. |
| | |
| | extent : (x0, x1, y0, y1), optional |
| | If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it |
| | gives the outer pixel boundaries. In this case, the position of z[0, 0] is |
| | the center of the pixel, not a corner. If *origin* is *None*, then |
| | (*x0*, *y0*) is the position of z[0, 0], and (*x1*, *y1*) is the position |
| | of z[-1, -1]. |
| | |
| | This argument is ignored if *X* and *Y* are specified in the call to |
| | contour. |
| | |
| | locator : ticker.Locator subclass, optional |
| | The locator is used to determine the contour levels if they are not given |
| | explicitly via *levels*. |
| | Defaults to `~.ticker.MaxNLocator`. |
| | |
| | extend : {'neither', 'both', 'min', 'max'}, default: 'neither' |
| | Determines the ``%%(func)s``-coloring of values that are outside the |
| | *levels* range. |
| | |
| | If 'neither', values outside the *levels* range are not colored. If 'min', |
| | 'max' or 'both', color the values below, above or below and above the |
| | *levels* range. |
| | |
| | Values below ``min(levels)`` and above ``max(levels)`` are mapped to the |
| | under/over values of the `.Colormap`. Note that most colormaps do not have |
| | dedicated colors for these by default, so that the over and under values |
| | are the edge values of the colormap. You may want to set these values |
| | explicitly using `.Colormap.set_under` and `.Colormap.set_over`. |
| | |
| | .. note:: |
| | |
| | An existing `.TriContourSet` does not get notified if properties of its |
| | colormap are changed. Therefore, an explicit call to |
| | `.ContourSet.changed()` is needed after modifying the colormap. The |
| | explicit call can be left out, if a colorbar is assigned to the |
| | `.TriContourSet` because it internally calls `.ContourSet.changed()`. |
| | |
| | xunits, yunits : registered units, optional |
| | Override axis units by specifying an instance of a |
| | :class:`matplotlib.units.ConversionInterface`. |
| | |
| | antialiased : bool, optional |
| | Enable antialiasing, overriding the defaults. For |
| | filled contours, the default is *True*. For line contours, |
| | it is taken from :rc:`lines.antialiased`.""" % _docstring.interpd.params) |
| |
|
| |
|
| | @_docstring.Substitution(func='tricontour', type='lines') |
| | @_docstring.dedent_interpd |
| | def tricontour(ax, *args, **kwargs): |
| | """ |
| | %(_tricontour_doc)s |
| | |
| | linewidths : float or array-like, default: :rc:`contour.linewidth` |
| | The line width of the contour lines. |
| | |
| | If a number, all levels will be plotted with this linewidth. |
| | |
| | If a sequence, the levels in ascending order will be plotted with |
| | the linewidths in the order specified. |
| | |
| | If None, this falls back to :rc:`lines.linewidth`. |
| | |
| | linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional |
| | If *linestyles* is *None*, the default is 'solid' unless the lines are |
| | monochrome. In that case, negative contours will take their linestyle |
| | from :rc:`contour.negative_linestyle` setting. |
| | |
| | *linestyles* can also be an iterable of the above strings specifying a |
| | set of linestyles to be used. If this iterable is shorter than the |
| | number of contour levels it will be repeated as necessary. |
| | """ |
| | kwargs['filled'] = False |
| | return TriContourSet(ax, *args, **kwargs) |
| |
|
| |
|
| | @_docstring.Substitution(func='tricontourf', type='regions') |
| | @_docstring.dedent_interpd |
| | def tricontourf(ax, *args, **kwargs): |
| | """ |
| | %(_tricontour_doc)s |
| | |
| | hatches : list[str], optional |
| | A list of crosshatch patterns to use on the filled areas. |
| | If None, no hatching will be added to the contour. |
| | Hatching is supported in the PostScript, PDF, SVG and Agg |
| | backends only. |
| | |
| | Notes |
| | ----- |
| | `.tricontourf` fills intervals that are closed at the top; that is, for |
| | boundaries *z1* and *z2*, the filled region is:: |
| | |
| | z1 < Z <= z2 |
| | |
| | except for the lowest interval, which is closed on both sides (i.e. it |
| | includes the lowest value). |
| | """ |
| | kwargs['filled'] = True |
| | return TriContourSet(ax, *args, **kwargs) |
| |
|
