def register_cmap(name=None, cmap=None, data=None, lut=None): """ Add a colormap to the set recognized by :func:`get_cmap`. It can be used in two ways:: register_cmap(name='swirly', cmap=swirly_cmap) register_cmap(name='choppy', data=choppydata, lut=128) In the first case, *cmap* must be a :class:`matplotlib.colors.Colormap` instance. The *name* is optional; if absent, the name will be the :attr:`~matplotlib.colors.Colormap.name` attribute of the *cmap*. In the second case, the three arguments are passed to the :class:`~matplotlib.colors.LinearSegmentedColormap` initializer, and the resulting colormap is registered. """ cbook._check_isinstance((str, None), name=name) if name is None: try: name = cmap.name except AttributeError: raise ValueError("Arguments must include a name or a Colormap") if isinstance(cmap, colors.Colormap): cmap_d[name] = cmap return # For the remainder, let exceptions propagate. if lut is None: lut = mpl.rcParams['image.lut'] cmap = colors.LinearSegmentedColormap(name, data, lut) cmap_d[name] = cmap
def update(self, data): """ Map new values to integer identifiers. Parameters ---------- data : iterable sequence of string values Raises ------ TypeError If the value in data is not a string, unicode, bytes type """ data = np.atleast_1d(np.array(data, dtype=object)) # check if convertible to number: convertible = True for val in OrderedDict.fromkeys(data): # OrderedDict just iterates over unique values in data. cbook._check_isinstance((str, bytes), value=val) if convertible: # this will only be called so long as convertible is True. convertible = self._str_is_convertible(val) if val not in self._mapping: self._mapping[val] = next(self._counter) if convertible: _log.info('Using categorical units to plot a list of strings ' 'that are all parsable as floats or dates. If these ' 'strings should be plotted as numbers, cast to the ' 'appropriate data type before plotting.')
def register_cmap(name=None, cmap=None, *, override_builtin=False): """ Add a colormap to the set recognized by :func:`get_cmap`. Register a new colormap to be accessed by name :: LinearSegmentedColormap('swirly', data, lut) register_cmap(cmap=swirly_cmap) Parameters ---------- name : str, optional The name that can be used in :func:`get_cmap` or :rc:`image.cmap` If absent, the name will be the :attr:`~matplotlib.colors.Colormap.name` attribute of the *cmap*. cmap : matplotlib.colors.Colormap Despite being the second argument and having a default value, this is a required argument. override_builtin : bool Allow built-in colormaps to be overridden by a user-supplied colormap. Please do not use this unless you are sure you need it. Notes ----- Registering a colormap stores a reference to the colormap object which can currently be modified and inadvertantly change the global colormap state. This behavior is deprecated and in Matplotlib 3.5 the registered colormap will be immutable. """ cbook._check_isinstance((str, None), name=name) if name is None: try: name = cmap.name except AttributeError as err: raise ValueError("Arguments must include a name or a " "Colormap") from err if name in _cmap_registry: if not override_builtin and name in __builtin_cmaps: msg = f"Trying to re-register the builtin cmap {name!r}." raise ValueError(msg) else: msg = f"Trying to register the cmap {name!r} which already exists." _warn_external(msg) if not isinstance(cmap, colors.Colormap): raise ValueError("You must pass a Colormap instance. " f"You passed {cmap} a {type(cmap)} object.") cmap._global = True _cmap_registry[name] = cmap return
def __init__(self, axes, spine_type, path, **kwargs): """ Parameters ---------- axes : `~matplotlib.axes.Axes` The `~.axes.Axes` instance containing the spine. spine_type : str The spine type. path : `~matplotlib.path.Path` The `.Path` instance used to draw the spine. Other Parameters ---------------- **kwargs Valid keyword arguments are: %(Patch)s """ super().__init__(**kwargs) self.axes = axes self.set_figure(self.axes.figure) self.spine_type = spine_type self.set_facecolor('none') self.set_edgecolor(rcParams['axes.edgecolor']) self.set_linewidth(rcParams['axes.linewidth']) self.set_capstyle('projecting') self.axis = None self.set_zorder(2.5) self.set_transform(self.axes.transData) # default transform self._bounds = None # default bounds self._smart_bounds = False # deprecated in 3.2 # Defer initial position determination. (Not much support for # non-rectangular axes is currently implemented, and this lets # them pass through the spines machinery without errors.) self._position = None cbook._check_isinstance(matplotlib.path.Path, path=path) self._path = path # To support drawing both linear and circular spines, this # class implements Patch behavior three ways. If # self._patch_type == 'line', behave like a mpatches.PathPatch # instance. If self._patch_type == 'circle', behave like a # mpatches.Ellipse instance. If self._patch_type == 'arc', behave like # a mpatches.Arc instance. self._patch_type = 'line' # Behavior copied from mpatches.Ellipse: # Note: This cannot be calculated until this is added to an Axes self._patch_transform = mtransforms.IdentityTransform()
def __init__(self, scale, tfm, texname, vf): cbook._check_isinstance(bytes, texname=texname) self._scale = scale self._tfm = tfm self.texname = texname self._vf = vf self.size = scale * (72.0 / (72.27 * 2**16)) try: nchars = max(tfm.width) + 1 except ValueError: nchars = 0 self.widths = [(1000 * tfm.width.get(char, 0)) >> 20 for char in range(nchars)]
def register_cmap(name=None, cmap=None, data=None, lut=None): """ Add a colormap to the set recognized by :func:`get_cmap`. It can be used in two ways:: register_cmap(name='swirly', cmap=swirly_cmap) register_cmap(name='choppy', data=choppydata, lut=128) In the first case, *cmap* must be a :class:`matplotlib.colors.Colormap` instance. The *name* is optional; if absent, the name will be the :attr:`~matplotlib.colors.Colormap.name` attribute of the *cmap*. The second case is deprecated. Here, the three arguments are passed to the :class:`~matplotlib.colors.LinearSegmentedColormap` initializer, and the resulting colormap is registered. Instead of this implicit colormap creation, create a `.LinearSegmentedColormap` and use the first case: ``register_cmap(cmap=LinearSegmentedColormap(name, data, lut))``. Notes ----- Registering a colormap stores a reference to the colormap object which can currently be modified and inadvertantly change the global colormap state. This behavior is deprecated and in Matplotlib 3.5 the registered colormap will be immutable. """ cbook._check_isinstance((str, None), name=name) if name is None: try: name = cmap.name except AttributeError as err: raise ValueError("Arguments must include a name or a " "Colormap") from err if isinstance(cmap, colors.Colormap): cmap._global = True _cmap_registry[name] = cmap return if lut is not None or data is not None: cbook.warn_deprecated( "3.3", message="Passing raw data via parameters data and lut to " "register_cmap() is deprecated. Instead use: " "register_cmap(" "cmap=LinearSegmentedColormap(name, data, lut))") # For the remainder, let exceptions propagate. if lut is None: lut = mpl.rcParams['image.lut'] cmap = colors.LinearSegmentedColormap(name, data, lut) cmap._global = True _cmap_registry[name] = cmap
def set_norm(self, norm): """Set the normalization instance. Parameters ---------- norm : `.Normalize` Notes ----- If there are any colorbars using the mappable for this norm, setting the norm of the mappable will reset the norm, locator, and formatters on the colorbar to default. """ cbook._check_isinstance((colors.Normalize, None), norm=norm) if norm is None: norm = colors.Normalize() self.norm = norm self.changed()
def refine_field(self, z, triinterpolator=None, subdiv=3): """ Refines a field defined on the encapsulated triangulation. Returns *refi_tri* (refined triangulation), *refi_z* (interpolated values of the field at the node of the refined triangulation). Parameters ---------- z : 1d-array-like of length ``n_points`` Values of the field to refine, defined at the nodes of the encapsulated triangulation. (``n_points`` is the number of points in the initial triangulation) triinterpolator : :class:`~matplotlib.tri.TriInterpolator`, optional Interpolator used for field interpolation. If not specified, a :class:`~matplotlib.tri.CubicTriInterpolator` will be used. subdiv : integer, optional Recursion level for the subdivision. Defaults to 3. Each triangle will be divided into ``4**subdiv`` child triangles. Returns ------- refi_tri : :class:`~matplotlib.tri.Triangulation` object The returned refined triangulation refi_z : 1d array of length: *refi_tri* node count. The returned interpolated field (at *refi_tri* nodes) """ if triinterpolator is None: interp = matplotlib.tri.CubicTriInterpolator( self._triangulation, z) else: cbook._check_isinstance(matplotlib.tri.TriInterpolator, triinterpolator=triinterpolator) interp = triinterpolator refi_tri, found_index = self.refine_triangulation( subdiv=subdiv, return_tri_index=True) refi_z = interp._interpolate_multikeys(refi_tri.x, refi_tri.y, tri_index=found_index)[0] return refi_tri, refi_z
def __call__(self, n=1, timeout=30): """Blocking call to retrieve *n* events.""" cbook._check_isinstance(Integral, n=n) self.n = n self.events = [] if hasattr(self.fig.canvas, "manager"): # Ensure that the figure is shown, if we are managing it. self.fig.show() # Connect the events to the on_event function call. self.callbacks = [self.fig.canvas.mpl_connect(name, self.on_event) for name in self.eventslist] try: # Start event loop. self.fig.canvas.start_event_loop(timeout=timeout) finally: # Run even on exception like ctrl-c. # Disconnect the callbacks. self.cleanup() # Return the events in this case. return self.events
def __init__(self, triangulation): cbook._check_isinstance(Triangulation, triangulation=triangulation) self._triangulation = triangulation
def __init__(self, fixed_size): cbook._check_isinstance(Number, fixed_size=fixed_size) self.fixed_size = fixed_size
def __init__(self, fraction, ref_size): cbook._check_isinstance(Number, fraction=fraction) self._fraction_ref = ref_size self._fraction = fraction
def tripcolor(ax, *args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs): """ Create a pseudocolor plot of an unstructured triangular grid. The triangulation can be specified in one of two ways; either:: tripcolor(triangulation, ...) where triangulation is a `.Triangulation` object, or :: tripcolor(x, y, ...) tripcolor(x, y, triangles, ...) tripcolor(x, y, triangles=triangles, ...) tripcolor(x, y, mask=mask, ...) tripcolor(x, y, triangles, mask=mask, ...) in which case a Triangulation object will be created. See `.Triangulation` for a explanation of these possibilities. The next argument must be *C*, the array of color values, either one per point in the triangulation if color values are defined at points, or one per triangle in the triangulation if color values are defined at triangles. If there are the same number of points and triangles in the triangulation it is assumed that color values are defined at points; to force the use of color values at triangles use the kwarg ``facecolors=C`` instead of just ``C``. *shading* may be 'flat' (the default) or 'gouraud'. If *shading* is 'flat' and C values are defined at points, the color values used for each triangle are from the mean C of the triangle's three points. If *shading* is 'gouraud' then color values must be defined at points. The remaining kwargs are the same as for `~.Axes.pcolor`. """ cbook._check_in_list(['flat', 'gouraud'], shading=shading) tri, args, kwargs = Triangulation.get_from_args_and_kwargs(*args, **kwargs) # C is the colors array defined at either points or faces (i.e. triangles). # If facecolors is None, C are defined at points. # If facecolors is not None, C are defined at faces. if facecolors is not None: C = facecolors else: C = np.asarray(args[0]) # If there are a different number of points and triangles in the # triangulation, can omit facecolors kwarg as it is obvious from # length of C whether it refers to points or faces. # Do not do this for gouraud shading. if (facecolors is None and len(C) == len(tri.triangles) and len(C) != len(tri.x) and shading != 'gouraud'): facecolors = C # Check length of C is OK. if ((facecolors is None and len(C) != len(tri.x)) or (facecolors is not None and len(C) != len(tri.triangles))): raise ValueError('Length of color values array must be the same ' 'as either the number of triangulation points ' 'or triangles') # Handling of linewidths, shading, edgecolors and antialiased as # in Axes.pcolor linewidths = (0.25,) if 'linewidth' in kwargs: kwargs['linewidths'] = kwargs.pop('linewidth') kwargs.setdefault('linewidths', linewidths) edgecolors = 'none' if 'edgecolor' in kwargs: kwargs['edgecolors'] = kwargs.pop('edgecolor') ec = kwargs.setdefault('edgecolors', edgecolors) if 'antialiased' in kwargs: kwargs['antialiaseds'] = kwargs.pop('antialiased') if 'antialiaseds' not in kwargs and ec.lower() == "none": kwargs['antialiaseds'] = False if shading == 'gouraud': if facecolors is not None: raise ValueError('Gouraud shading does not support the use ' 'of facecolors kwarg') if len(C) != len(tri.x): raise ValueError('For gouraud shading, the length of color ' 'values array must be the same as the ' 'number of triangulation points') collection = TriMesh(tri, **kwargs) else: # Vertices of triangles. maskedTris = tri.get_masked_triangles() verts = np.stack((tri.x[maskedTris], tri.y[maskedTris]), axis=-1) # Color values. if facecolors is None: # One color per triangle, the mean of the 3 vertex color values. C = C[maskedTris].mean(axis=1) elif tri.mask is not None: # Remove color values of masked triangles. C = C[~tri.mask] collection = PolyCollection(verts, **kwargs) collection.set_alpha(alpha) collection.set_array(C) cbook._check_isinstance((Normalize, None), norm=norm) collection.set_cmap(cmap) collection.set_norm(norm) collection._scale_norm(norm, vmin, vmax) ax.grid(False) minx = tri.x.min() maxx = tri.x.max() miny = tri.y.min() maxy = tri.y.max() corners = (minx, miny), (maxx, maxy) ax.update_datalim(corners) ax.autoscale_view() ax.add_collection(collection) return collection