""" GUI neutral widgets =================== Widgets that are designed to work for any of the GUI backends. All of these widgets require you to predefine a `matplotlib.axes.Axes` instance and pass that as the first parameter. Matplotlib doesn't try to be too smart with respect to layout -- you will have to figure out how wide and tall you want your Axes to be to accommodate your widget. """ from contextlib import ExitStack import copy from numbers import Integral, Number import numpy as np import matplotlib as mpl from matplotlib import docstring from . import _api, backend_tools, cbook, colors, ticker from .lines import Line2D from .patches import Circle, Rectangle, Ellipse from .transforms import TransformedPatchPath class LockDraw: """ Some widgets, like the cursor, draw onto the canvas, and this is not desirable under all circumstances, like when the toolbar is in zoom-to-rect mode and drawing a rectangle. To avoid this, a widget can acquire a canvas' lock with ``canvas.widgetlock(widget)`` before drawing on the canvas; this will prevent other widgets from doing so at the same time (if they also try to acquire the lock first). """ def __init__(self): self._owner = None def __call__(self, o): """Reserve the lock for *o*.""" if not self.available(o): raise ValueError('already locked') self._owner = o def release(self, o): """Release the lock from *o*.""" if not self.available(o): raise ValueError('you do not own this lock') self._owner = None def available(self, o): """Return whether drawing is available to *o*.""" return not self.locked() or self.isowner(o) def isowner(self, o): """Return whether *o* owns this lock.""" return self._owner is o def locked(self): """Return whether the lock is currently held by an owner.""" return self._owner is not None class Widget: """ Abstract base class for GUI neutral widgets. """ drawon = True eventson = True _active = True def set_active(self, active): """Set whether the widget is active.""" self._active = active def get_active(self): """Get whether the widget is active.""" return self._active # set_active is overridden by SelectorWidgets. active = property(get_active, set_active, doc="Is the widget active?") def ignore(self, event): """ Return whether *event* should be ignored. This method should be called at the beginning of any event callback. """ return not self.active class AxesWidget(Widget): """ Widget connected to a single `~matplotlib.axes.Axes`. To guarantee that the widget remains responsive and not garbage-collected, a reference to the object should be maintained by the user. This is necessary because the callback registry maintains only weak-refs to the functions, which are member functions of the widget. If there are no references to the widget object it may be garbage collected which will disconnect the callbacks. Attributes ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. canvas : `~matplotlib.backend_bases.FigureCanvasBase` The parent figure canvas for the widget. active : bool If False, the widget does not respond to events. """ cids = _api.deprecated("3.4")(property(lambda self: self._cids)) def __init__(self, ax): self.ax = ax self.canvas = ax.figure.canvas self._cids = [] def connect_event(self, event, callback): """ Connect a callback function with an event. This should be used in lieu of ``figure.canvas.mpl_connect`` since this function stores callback ids for later clean up. """ cid = self.canvas.mpl_connect(event, callback) self._cids.append(cid) def disconnect_events(self): """Disconnect all events created by this widget.""" for c in self._cids: self.canvas.mpl_disconnect(c) class Button(AxesWidget): """ A GUI neutral button. For the button to remain responsive you must keep a reference to it. Call `.on_clicked` to connect to the button. Attributes ---------- ax The `matplotlib.axes.Axes` the button renders into. label A `matplotlib.text.Text` instance. color The color of the button when not hovering. hovercolor The color of the button when hovering. """ cnt = _api.deprecated("3.4")(property( # Not real, but close enough. lambda self: len(self._observers.callbacks['clicked']))) observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['clicked'])) def __init__(self, ax, label, image=None, color='0.85', hovercolor='0.95'): """ Parameters ---------- ax : `~matplotlib.axes.Axes` The `~.axes.Axes` instance the button will be placed into. label : str The button text. image : array-like or PIL Image The image to place in the button, if not *None*. The parameter is directly forwarded to `~matplotlib.axes.Axes.imshow`. color : color The color of the button when not activated. hovercolor : color The color of the button when the mouse is over it. """ super().__init__(ax) if image is not None: ax.imshow(image) self.label = ax.text(0.5, 0.5, label, verticalalignment='center', horizontalalignment='center', transform=ax.transAxes) self._observers = cbook.CallbackRegistry() self.connect_event('button_press_event', self._click) self.connect_event('button_release_event', self._release) self.connect_event('motion_notify_event', self._motion) ax.set_navigate(False) ax.set_facecolor(color) ax.set_xticks([]) ax.set_yticks([]) self.color = color self.hovercolor = hovercolor def _click(self, event): if self.ignore(event) or event.inaxes != self.ax or not self.eventson: return if event.canvas.mouse_grabber != self.ax: event.canvas.grab_mouse(self.ax) def _release(self, event): if self.ignore(event) or event.canvas.mouse_grabber != self.ax: return event.canvas.release_mouse(self.ax) if self.eventson and event.inaxes == self.ax: self._observers.process('clicked', event) def _motion(self, event): if self.ignore(event): return c = self.hovercolor if event.inaxes == self.ax else self.color if not colors.same_color(c, self.ax.get_facecolor()): self.ax.set_facecolor(c) if self.drawon: self.ax.figure.canvas.draw() def on_clicked(self, func): """ Connect the callback function *func* to button click events. Returns a connection id, which can be used to disconnect the callback. """ return self._observers.connect('clicked', lambda event: func(event)) def disconnect(self, cid): """Remove the callback function with connection id *cid*.""" self._observers.disconnect(cid) class SliderBase(AxesWidget): """ The base class for constructing Slider widgets. Not intended for direct usage. For the slider to remain responsive you must maintain a reference to it. """ def __init__(self, ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep): if ax.name == '3d': raise ValueError('Sliders cannot be added to 3D Axes') super().__init__(ax) _api.check_in_list(['horizontal', 'vertical'], orientation=orientation) self.orientation = orientation self.closedmin = closedmin self.closedmax = closedmax self.valmin = valmin self.valmax = valmax self.valstep = valstep self.drag_active = False self.valfmt = valfmt if orientation == "vertical": ax.set_ylim((valmin, valmax)) axis = ax.yaxis else: ax.set_xlim((valmin, valmax)) axis = ax.xaxis self._fmt = axis.get_major_formatter() if not isinstance(self._fmt, ticker.ScalarFormatter): self._fmt = ticker.ScalarFormatter() self._fmt.set_axis(axis) self._fmt.set_useOffset(False) # No additive offset. self._fmt.set_useMathText(True) # x sign before multiplicative offset. ax.set_axis_off() ax.set_navigate(False) self.connect_event("button_press_event", self._update) self.connect_event("button_release_event", self._update) if dragging: self.connect_event("motion_notify_event", self._update) self._observers = cbook.CallbackRegistry() def _stepped_value(self, val): """Return *val* coerced to closest number in the ``valstep`` grid.""" if isinstance(self.valstep, Number): val = (self.valmin + round((val - self.valmin) / self.valstep) * self.valstep) elif self.valstep is not None: valstep = np.asanyarray(self.valstep) if valstep.ndim != 1: raise ValueError( f"valstep must have 1 dimension but has {valstep.ndim}" ) val = valstep[np.argmin(np.abs(valstep - val))] return val def disconnect(self, cid): """ Remove the observer with connection id *cid*. Parameters ---------- cid : int Connection id of the observer to be removed. """ self._observers.disconnect(cid) def reset(self): """Reset the slider to the initial value.""" if np.any(self.val != self.valinit): self.set_val(self.valinit) class Slider(SliderBase): """ A slider representing a floating point range. Create a slider from *valmin* to *valmax* in axes *ax*. For the slider to remain responsive you must maintain a reference to it. Call :meth:`on_changed` to connect to the slider event. Attributes ---------- val : float Slider value. """ cnt = _api.deprecated("3.4")(property( # Not real, but close enough. lambda self: len(self._observers.callbacks['changed']))) observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['changed'])) def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt=None, closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, valstep=None, orientation='horizontal', *, initcolor='r', track_color='lightgrey', handle_style=None, **kwargs): """ Parameters ---------- ax : Axes The Axes to put the slider in. label : str Slider label. valmin : float The minimum value of the slider. valmax : float The maximum value of the slider. valinit : float, default: 0.5 The slider initial position. valfmt : str, default: None %-format string used to format the slider value. If None, a `.ScalarFormatter` is used instead. closedmin : bool, default: True Whether the slider interval is closed on the bottom. closedmax : bool, default: True Whether the slider interval is closed on the top. slidermin : Slider, default: None Do not allow the current slider to have a value less than the value of the Slider *slidermin*. slidermax : Slider, default: None Do not allow the current slider to have a value greater than the value of the Slider *slidermax*. dragging : bool, default: True If True the slider can be dragged by the mouse. valstep : float or array-like, default: None If a float, the slider will snap to multiples of *valstep*. If an array the slider will snap to the values in the array. orientation : {'horizontal', 'vertical'}, default: 'horizontal' The orientation of the slider. initcolor : color, default: 'r' The color of the line at the *valinit* position. Set to ``'none'`` for no line. track_color : color, default: 'lightgrey' The color of the background track. The track is accessible for further styling via the *track* attribute. handle_style : dict Properties of the slider handle. Default values are ========= ===== ======= ======================================== Key Value Default Description ========= ===== ======= ======================================== facecolor color 'white' The facecolor of the slider handle. edgecolor color '.75' The edgecolor of the slider handle. size int 10 The size of the slider handle in points. ========= ===== ======= ======================================== Other values will be transformed as marker{foo} and passed to the `~.Line2D` constructor. e.g. ``handle_style = {'style'='x'}`` will result in ``markerstyle = 'x'``. Notes ----- Additional kwargs are passed on to ``self.poly`` which is the `~matplotlib.patches.Polygon` that draws the slider knob. See the `.Polygon` documentation for valid property names (``facecolor``, ``edgecolor``, ``alpha``, etc.). """ super().__init__(ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep) if slidermin is not None and not hasattr(slidermin, 'val'): raise ValueError( f"Argument slidermin ({type(slidermin)}) has no 'val'") if slidermax is not None and not hasattr(slidermax, 'val'): raise ValueError( f"Argument slidermax ({type(slidermax)}) has no 'val'") self.slidermin = slidermin self.slidermax = slidermax valinit = self._value_in_bounds(valinit) if valinit is None: valinit = valmin self.val = valinit self.valinit = valinit defaults = {'facecolor': 'white', 'edgecolor': '.75', 'size': 10} handle_style = {} if handle_style is None else handle_style marker_props = { f'marker{k}': v for k, v in {**defaults, **handle_style}.items() } if orientation == 'vertical': self.track = Rectangle( (.25, 0), .5, 1, transform=ax.transAxes, facecolor=track_color ) ax.add_patch(self.track) self.poly = ax.axhspan(valmin, valinit, .25, .75, **kwargs) # Drawing a longer line and clipping it to the track avoids # pixellization-related asymmetries. self.hline = ax.axhline(valinit, 0, 1, color=initcolor, lw=1, clip_path=TransformedPatchPath(self.track)) handleXY = [[0.5], [valinit]] else: self.track = Rectangle( (0, .25), 1, .5, transform=ax.transAxes, facecolor=track_color ) ax.add_patch(self.track) self.poly = ax.axvspan(valmin, valinit, .25, .75, **kwargs) self.vline = ax.axvline(valinit, 0, 1, color=initcolor, lw=1, clip_path=TransformedPatchPath(self.track)) handleXY = [[valinit], [0.5]] self._handle, = ax.plot( *handleXY, "o", **marker_props, clip_on=False ) if orientation == 'vertical': self.label = ax.text(0.5, 1.02, label, transform=ax.transAxes, verticalalignment='bottom', horizontalalignment='center') self.valtext = ax.text(0.5, -0.02, self._format(valinit), transform=ax.transAxes, verticalalignment='top', horizontalalignment='center') else: self.label = ax.text(-0.02, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right') self.valtext = ax.text(1.02, 0.5, self._format(valinit), transform=ax.transAxes, verticalalignment='center', horizontalalignment='left') self.set_val(valinit) def _value_in_bounds(self, val): """Makes sure *val* is with given bounds.""" val = self._stepped_value(val) if val <= self.valmin: if not self.closedmin: return val = self.valmin elif val >= self.valmax: if not self.closedmax: return val = self.valmax if self.slidermin is not None and val <= self.slidermin.val: if not self.closedmin: return val = self.slidermin.val if self.slidermax is not None and val >= self.slidermax.val: if not self.closedmax: return val = self.slidermax.val return val def _update(self, event): """Update the slider position.""" if self.ignore(event) or event.button != 1: return if event.name == 'button_press_event' and event.inaxes == self.ax: self.drag_active = True event.canvas.grab_mouse(self.ax) if not self.drag_active: return elif ((event.name == 'button_release_event') or (event.name == 'button_press_event' and event.inaxes != self.ax)): self.drag_active = False event.canvas.release_mouse(self.ax) return if self.orientation == 'vertical': val = self._value_in_bounds(event.ydata) else: val = self._value_in_bounds(event.xdata) if val not in [None, self.val]: self.set_val(val) def _format(self, val): """Pretty-print *val*.""" if self.valfmt is not None: return self.valfmt % val else: _, s, _ = self._fmt.format_ticks([self.valmin, val, self.valmax]) # fmt.get_offset is actually the multiplicative factor, if any. return s + self._fmt.get_offset() def set_val(self, val): """ Set slider value to *val*. Parameters ---------- val : float """ xy = self.poly.xy if self.orientation == 'vertical': xy[1] = .25, val xy[2] = .75, val self._handle.set_ydata([val]) else: xy[2] = val, .75 xy[3] = val, .25 self._handle.set_xdata([val]) self.poly.xy = xy self.valtext.set_text(self._format(val)) if self.drawon: self.ax.figure.canvas.draw_idle() self.val = val if self.eventson: self._observers.process('changed', val) def on_changed(self, func): """ Connect *func* as callback function to changes of the slider value. Parameters ---------- func : callable Function to call when slider is changed. The function must accept a single float as its arguments. Returns ------- int Connection id (which can be used to disconnect *func*). """ return self._observers.connect('changed', lambda val: func(val)) class RangeSlider(SliderBase): """ A slider representing a range of floating point values. Defines the min and max of the range via the *val* attribute as a tuple of (min, max). Create a slider that defines a range contained within [*valmin*, *valmax*] in axes *ax*. For the slider to remain responsive you must maintain a reference to it. Call :meth:`on_changed` to connect to the slider event. Attributes ---------- val : tuple of float Slider value. """ def __init__( self, ax, label, valmin, valmax, valinit=None, valfmt=None, closedmin=True, closedmax=True, dragging=True, valstep=None, orientation="horizontal", track_color='lightgrey', handle_style=None, **kwargs, ): """ Parameters ---------- ax : Axes The Axes to put the slider in. label : str Slider label. valmin : float The minimum value of the slider. valmax : float The maximum value of the slider. valinit : tuple of float or None, default: None The initial positions of the slider. If None the initial positions will be at the 25th and 75th percentiles of the range. valfmt : str, default: None %-format string used to format the slider values. If None, a `.ScalarFormatter` is used instead. closedmin : bool, default: True Whether the slider interval is closed on the bottom. closedmax : bool, default: True Whether the slider interval is closed on the top. dragging : bool, default: True If True the slider can be dragged by the mouse. valstep : float, default: None If given, the slider will snap to multiples of *valstep*. orientation : {'horizontal', 'vertical'}, default: 'horizontal' The orientation of the slider. track_color : color, default: 'lightgrey' The color of the background track. The track is accessible for further styling via the *track* attribute. handle_style : dict Properties of the slider handles. Default values are ========= ===== ======= ========================================= Key Value Default Description ========= ===== ======= ========================================= facecolor color 'white' The facecolor of the slider handles. edgecolor color '.75' The edgecolor of the slider handles. size int 10 The size of the slider handles in points. ========= ===== ======= ========================================= Other values will be transformed as marker{foo} and passed to the `~.Line2D` constructor. e.g. ``handle_style = {'style'='x'}`` will result in ``markerstyle = 'x'``. Notes ----- Additional kwargs are passed on to ``self.poly`` which is the `~matplotlib.patches.Polygon` that draws the slider knob. See the `.Polygon` documentation for valid property names (``facecolor``, ``edgecolor``, ``alpha``, etc.). """ super().__init__(ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep) # Set a value to allow _value_in_bounds() to work. self.val = [valmin, valmax] if valinit is None: # Place at the 25th and 75th percentiles extent = valmax - valmin valinit = np.array([valmin + extent * 0.25, valmin + extent * 0.75]) else: valinit = self._value_in_bounds(valinit) self.val = valinit self.valinit = valinit defaults = {'facecolor': 'white', 'edgecolor': '.75', 'size': 10} handle_style = {} if handle_style is None else handle_style marker_props = { f'marker{k}': v for k, v in {**defaults, **handle_style}.items() } if orientation == "vertical": self.track = Rectangle( (.25, 0), .5, 2, transform=ax.transAxes, facecolor=track_color ) ax.add_patch(self.track) self.poly = ax.axhspan(valinit[0], valinit[1], 0, 1, **kwargs) handleXY_1 = [.5, valinit[0]] handleXY_2 = [.5, valinit[1]] else: self.track = Rectangle( (0, .25), 1, .5, transform=ax.transAxes, facecolor=track_color ) ax.add_patch(self.track) self.poly = ax.axvspan(valinit[0], valinit[1], 0, 1, **kwargs) handleXY_1 = [valinit[0], .5] handleXY_2 = [valinit[1], .5] self._handles = [ ax.plot( *handleXY_1, "o", **marker_props, clip_on=False )[0], ax.plot( *handleXY_2, "o", **marker_props, clip_on=False )[0] ] if orientation == "vertical": self.label = ax.text( 0.5, 1.02, label, transform=ax.transAxes, verticalalignment="bottom", horizontalalignment="center", ) self.valtext = ax.text( 0.5, -0.02, self._format(valinit), transform=ax.transAxes, verticalalignment="top", horizontalalignment="center", ) else: self.label = ax.text( -0.02, 0.5, label, transform=ax.transAxes, verticalalignment="center", horizontalalignment="right", ) self.valtext = ax.text( 1.02, 0.5, self._format(valinit), transform=ax.transAxes, verticalalignment="center", horizontalalignment="left", ) self._active_handle = None self.set_val(valinit) def _min_in_bounds(self, min): """Ensure the new min value is between valmin and self.val[1].""" if min <= self.valmin: if not self.closedmin: return self.val[0] min = self.valmin if min > self.val[1]: min = self.val[1] return self._stepped_value(min) def _max_in_bounds(self, max): """Ensure the new max value is between valmax and self.val[0].""" if max >= self.valmax: if not self.closedmax: return self.val[1] max = self.valmax if max <= self.val[0]: max = self.val[0] return self._stepped_value(max) def _value_in_bounds(self, vals): """Clip min, max values to the bounds.""" return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1])) def _update_val_from_pos(self, pos): """Update the slider value based on a given position.""" idx = np.argmin(np.abs(self.val - pos)) if idx == 0: val = self._min_in_bounds(pos) self.set_min(val) else: val = self._max_in_bounds(pos) self.set_max(val) if self._active_handle: self._active_handle.set_xdata([val]) def _update(self, event): """Update the slider position.""" if self.ignore(event) or event.button != 1: return if event.name == "button_press_event" and event.inaxes == self.ax: self.drag_active = True event.canvas.grab_mouse(self.ax) if not self.drag_active: return elif (event.name == "button_release_event") or ( event.name == "button_press_event" and event.inaxes != self.ax ): self.drag_active = False event.canvas.release_mouse(self.ax) self._active_handle = None return # determine which handle was grabbed handle = self._handles[ np.argmin( np.abs([h.get_xdata()[0] - event.xdata for h in self._handles]) ) ] # these checks ensure smooth behavior if the handles swap which one # has a higher value. i.e. if one is dragged over and past the other. if handle is not self._active_handle: self._active_handle = handle if self.orientation == "vertical": self._update_val_from_pos(event.ydata) else: self._update_val_from_pos(event.xdata) def _format(self, val): """Pretty-print *val*.""" if self.valfmt is not None: return f"({self.valfmt % val[0]}, {self.valfmt % val[1]})" else: _, s1, s2, _ = self._fmt.format_ticks( [self.valmin, *val, self.valmax] ) # fmt.get_offset is actually the multiplicative factor, if any. s1 += self._fmt.get_offset() s2 += self._fmt.get_offset() # Use f string to avoid issues with backslashes when cast to a str return f"({s1}, {s2})" def set_min(self, min): """ Set the lower value of the slider to *min*. Parameters ---------- min : float """ self.set_val((min, self.val[1])) def set_max(self, max): """ Set the lower value of the slider to *max*. Parameters ---------- max : float """ self.set_val((self.val[0], max)) def set_val(self, val): """ Set slider value to *val*. Parameters ---------- val : tuple or array-like of float """ val = np.sort(np.asanyarray(val)) if val.shape != (2,): raise ValueError( f"val must have shape (2,) but has shape {val.shape}" ) val[0] = self._min_in_bounds(val[0]) val[1] = self._max_in_bounds(val[1]) xy = self.poly.xy if self.orientation == "vertical": xy[0] = .25, val[0] xy[1] = .25, val[1] xy[2] = .75, val[1] xy[3] = .75, val[0] xy[4] = .25, val[0] else: xy[0] = val[0], .25 xy[1] = val[0], .75 xy[2] = val[1], .75 xy[3] = val[1], .25 xy[4] = val[0], .25 self.poly.xy = xy self.valtext.set_text(self._format(val)) if self.drawon: self.ax.figure.canvas.draw_idle() self.val = val if self.eventson: self._observers.process("changed", val) def on_changed(self, func): """ Connect *func* as callback function to changes of the slider value. Parameters ---------- func : callable Function to call when slider is changed. The function must accept a numpy array with shape (2,) as its argument. Returns ------- int Connection id (which can be used to disconnect *func*). """ return self._observers.connect('changed', lambda val: func(val)) class CheckButtons(AxesWidget): r""" A GUI neutral set of check buttons. For the check buttons to remain responsive you must keep a reference to this object. Connect to the CheckButtons with the `.on_clicked` method. Attributes ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. labels : list of `.Text` rectangles : list of `.Rectangle` lines : list of (`.Line2D`, `.Line2D`) pairs List of lines for the x's in the check boxes. These lines exist for each box, but have ``set_visible(False)`` when its box is not checked. """ cnt = _api.deprecated("3.4")(property( # Not real, but close enough. lambda self: len(self._observers.callbacks['clicked']))) observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['clicked'])) def __init__(self, ax, labels, actives=None): """ Add check buttons to `matplotlib.axes.Axes` instance *ax*. Parameters ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. labels : list of str The labels of the check buttons. actives : list of bool, optional The initial check states of the buttons. The list must have the same length as *labels*. If not given, all buttons are unchecked. """ super().__init__(ax) ax.set_xticks([]) ax.set_yticks([]) ax.set_navigate(False) if actives is None: actives = [False] * len(labels) if len(labels) > 1: dy = 1. / (len(labels) + 1) ys = np.linspace(1 - dy, dy, len(labels)) else: dy = 0.25 ys = [0.5] axcolor = ax.get_facecolor() self.labels = [] self.lines = [] self.rectangles = [] lineparams = {'color': 'k', 'linewidth': 1.25, 'transform': ax.transAxes, 'solid_capstyle': 'butt'} for y, label, active in zip(ys, labels, actives): t = ax.text(0.25, y, label, transform=ax.transAxes, horizontalalignment='left', verticalalignment='center') w, h = dy / 2, dy / 2 x, y = 0.05, y - h / 2 p = Rectangle(xy=(x, y), width=w, height=h, edgecolor='black', facecolor=axcolor, transform=ax.transAxes) l1 = Line2D([x, x + w], [y + h, y], **lineparams) l2 = Line2D([x, x + w], [y, y + h], **lineparams) l1.set_visible(active) l2.set_visible(active) self.labels.append(t) self.rectangles.append(p) self.lines.append((l1, l2)) ax.add_patch(p) ax.add_line(l1) ax.add_line(l2) self.connect_event('button_press_event', self._clicked) self._observers = cbook.CallbackRegistry() def _clicked(self, event): if self.ignore(event) or event.button != 1 or event.inaxes != self.ax: return for i, (p, t) in enumerate(zip(self.rectangles, self.labels)): if (t.get_window_extent().contains(event.x, event.y) or p.get_window_extent().contains(event.x, event.y)): self.set_active(i) break def set_active(self, index): """ Toggle (activate or deactivate) a check button by index. Callbacks will be triggered if :attr:`eventson` is True. Parameters ---------- index : int Index of the check button to toggle. Raises ------ ValueError If *index* is invalid. """ if index not in range(len(self.labels)): raise ValueError(f'Invalid CheckButton index: {index}') l1, l2 = self.lines[index] l1.set_visible(not l1.get_visible()) l2.set_visible(not l2.get_visible()) if self.drawon: self.ax.figure.canvas.draw() if self.eventson: self._observers.process('clicked', self.labels[index].get_text()) def get_status(self): """ Return a tuple of the status (True/False) of all of the check buttons. """ return [l1.get_visible() for (l1, l2) in self.lines] def on_clicked(self, func): """ Connect the callback function *func* to button click events. Returns a connection id, which can be used to disconnect the callback. """ return self._observers.connect('clicked', lambda text: func(text)) def disconnect(self, cid): """Remove the observer with connection id *cid*.""" self._observers.disconnect(cid) class TextBox(AxesWidget): """ A GUI neutral text input box. For the text box to remain responsive you must keep a reference to it. Call `.on_text_change` to be updated whenever the text changes. Call `.on_submit` to be updated whenever the user hits enter or leaves the text entry field. Attributes ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. label : `.Text` color : color The color of the text box when not hovering. hovercolor : color The color of the text box when hovering. """ cnt = _api.deprecated("3.4")(property( # Not real, but close enough. lambda self: sum(len(d) for d in self._observers.callbacks.values()))) change_observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['change'])) submit_observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['submit'])) DIST_FROM_LEFT = _api.deprecate_privatize_attribute("3.5") def __init__(self, ax, label, initial='', color='.95', hovercolor='1', label_pad=.01, textalignment="left"): """ Parameters ---------- ax : `~matplotlib.axes.Axes` The `~.axes.Axes` instance the button will be placed into. label : str Label for this text box. initial : str Initial value in the text box. color : color The color of the box. hovercolor : color The color of the box when the mouse is over it. label_pad : float The distance between the label and the right side of the textbox. textalignment : {'left', 'center', 'right'} The horizontal location of the text. """ super().__init__(ax) self._DIST_FROM_LEFT = .05 self._text_position = _api.check_getitem( {"left": 0.05, "center": 0.5, "right": 0.95}, textalignment=textalignment) self.label = ax.text( -label_pad, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right') # TextBox's text object should not parse mathtext at all. self.text_disp = self.ax.text( self._text_position, 0.5, initial, transform=self.ax.transAxes, verticalalignment='center', horizontalalignment=textalignment, parse_math=False) self._observers = cbook.CallbackRegistry() ax.set( xlim=(0, 1), ylim=(0, 1), # s.t. cursor appears from first click. navigate=False, facecolor=color, xticks=[], yticks=[]) self.cursor_index = 0 self.cursor = ax.vlines(0, 0, 0, visible=False, color="k", lw=1, transform=mpl.transforms.IdentityTransform()) self.connect_event('button_press_event', self._click) self.connect_event('button_release_event', self._release) self.connect_event('motion_notify_event', self._motion) self.connect_event('key_press_event', self._keypress) self.connect_event('resize_event', self._resize) self.color = color self.hovercolor = hovercolor self.capturekeystrokes = False @property def text(self): return self.text_disp.get_text() def _rendercursor(self): # this is a hack to figure out where the cursor should go. # we draw the text up to where the cursor should go, measure # and save its dimensions, draw the real text, then put the cursor # at the saved dimensions # This causes a single extra draw if the figure has never been rendered # yet, which should be fine as we're going to repeatedly re-render the # figure later anyways. if self.ax.figure._cachedRenderer is None: self.ax.figure.canvas.draw() text = self.text_disp.get_text() # Save value before overwriting it. widthtext = text[:self.cursor_index] bb_text = self.text_disp.get_window_extent() self.text_disp.set_text(widthtext or ",") bb_widthtext = self.text_disp.get_window_extent() if bb_text.y0 == bb_text.y1: # Restoring the height if no text. bb_text.y0 -= (bb_widthtext.y1-bb_widthtext.y0)/2 bb_text.y1 += (bb_widthtext.y1-bb_widthtext.y0)/2 elif not widthtext: # Keep width to 0. bb_text.x1 = bb_text.x0 else: # Move the cursor using width of bb_widthtext. bb_text.x1 = bb_text.x0 + (bb_widthtext.x1 - bb_widthtext.x0) self.cursor.set( segments=[[(bb_text.x1, bb_text.y0), (bb_text.x1, bb_text.y1)]], visible=True) self.text_disp.set_text(text) self.ax.figure.canvas.draw() def _release(self, event): if self.ignore(event): return if event.canvas.mouse_grabber != self.ax: return event.canvas.release_mouse(self.ax) def _keypress(self, event): if self.ignore(event): return if self.capturekeystrokes: key = event.key text = self.text if len(key) == 1: text = (text[:self.cursor_index] + key + text[self.cursor_index:]) self.cursor_index += 1 elif key == "right": if self.cursor_index != len(text): self.cursor_index += 1 elif key == "left": if self.cursor_index != 0: self.cursor_index -= 1 elif key == "home": self.cursor_index = 0 elif key == "end": self.cursor_index = len(text) elif key == "backspace": if self.cursor_index != 0: text = (text[:self.cursor_index - 1] + text[self.cursor_index:]) self.cursor_index -= 1 elif key == "delete": if self.cursor_index != len(self.text): text = (text[:self.cursor_index] + text[self.cursor_index + 1:]) self.text_disp.set_text(text) self._rendercursor() if self.eventson: self._observers.process('change', self.text) if key in ["enter", "return"]: self._observers.process('submit', self.text) def set_val(self, val): newval = str(val) if self.text == newval: return self.text_disp.set_text(newval) self._rendercursor() if self.eventson: self._observers.process('change', self.text) self._observers.process('submit', self.text) def begin_typing(self, x): self.capturekeystrokes = True # Disable keypress shortcuts, which may otherwise cause the figure to # be saved, closed, etc., until the user stops typing. The way to # achieve this depends on whether toolmanager is in use. stack = ExitStack() # Register cleanup actions when user stops typing. self._on_stop_typing = stack.close toolmanager = getattr( self.ax.figure.canvas.manager, "toolmanager", None) if toolmanager is not None: # If using toolmanager, lock keypresses, and plan to release the # lock when typing stops. toolmanager.keypresslock(self) stack.callback(toolmanager.keypresslock.release, self) else: # If not using toolmanager, disable all keypress-related rcParams. # Avoid spurious warnings if keymaps are getting deprecated. with _api.suppress_matplotlib_deprecation_warning(): stack.enter_context(mpl.rc_context( {k: [] for k in mpl.rcParams if k.startswith("keymap.")})) def stop_typing(self): if self.capturekeystrokes: self._on_stop_typing() self._on_stop_typing = None notifysubmit = True else: notifysubmit = False self.capturekeystrokes = False self.cursor.set_visible(False) self.ax.figure.canvas.draw() if notifysubmit and self.eventson: # Because process() might throw an error in the user's code, only # call it once we've already done our cleanup. self._observers.process('submit', self.text) def position_cursor(self, x): # now, we have to figure out where the cursor goes. # approximate it based on assuming all characters the same length if len(self.text) == 0: self.cursor_index = 0 else: bb = self.text_disp.get_window_extent() ratio = np.clip((x - bb.x0) / bb.width, 0, 1) self.cursor_index = int(len(self.text) * ratio) self._rendercursor() def _click(self, event): if self.ignore(event): return if event.inaxes != self.ax: self.stop_typing() return if not self.eventson: return if event.canvas.mouse_grabber != self.ax: event.canvas.grab_mouse(self.ax) if not self.capturekeystrokes: self.begin_typing(event.x) self.position_cursor(event.x) def _resize(self, event): self.stop_typing() def _motion(self, event): if self.ignore(event): return c = self.hovercolor if event.inaxes == self.ax else self.color if not colors.same_color(c, self.ax.get_facecolor()): self.ax.set_facecolor(c) if self.drawon: self.ax.figure.canvas.draw() def on_text_change(self, func): """ When the text changes, call this *func* with event. A connection id is returned which can be used to disconnect. """ return self._observers.connect('change', lambda text: func(text)) def on_submit(self, func): """ When the user hits enter or leaves the submission box, call this *func* with event. A connection id is returned which can be used to disconnect. """ return self._observers.connect('submit', lambda text: func(text)) def disconnect(self, cid): """Remove the observer with connection id *cid*.""" self._observers.disconnect(cid) class RadioButtons(AxesWidget): """ A GUI neutral radio button. For the buttons to remain responsive you must keep a reference to this object. Connect to the RadioButtons with the `.on_clicked` method. Attributes ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. activecolor : color The color of the selected button. labels : list of `.Text` The button labels. circles : list of `~.patches.Circle` The buttons. value_selected : str The label text of the currently selected button. """ def __init__(self, ax, labels, active=0, activecolor='blue'): """ Add radio buttons to an `~.axes.Axes`. Parameters ---------- ax : `~matplotlib.axes.Axes` The axes to add the buttons to. labels : list of str The button labels. active : int The index of the initially selected button. activecolor : color The color of the selected button. """ super().__init__(ax) self.activecolor = activecolor self.value_selected = None ax.set_xticks([]) ax.set_yticks([]) ax.set_navigate(False) dy = 1. / (len(labels) + 1) ys = np.linspace(1 - dy, dy, len(labels)) cnt = 0 axcolor = ax.get_facecolor() # scale the radius of the circle with the spacing between each one circle_radius = dy / 2 - 0.01 # default to hard-coded value if the radius becomes too large circle_radius = min(circle_radius, 0.05) self.labels = [] self.circles = [] for y, label in zip(ys, labels): t = ax.text(0.25, y, label, transform=ax.transAxes, horizontalalignment='left', verticalalignment='center') if cnt == active: self.value_selected = label facecolor = activecolor else: facecolor = axcolor p = Circle(xy=(0.15, y), radius=circle_radius, edgecolor='black', facecolor=facecolor, transform=ax.transAxes) self.labels.append(t) self.circles.append(p) ax.add_patch(p) cnt += 1 self.connect_event('button_press_event', self._clicked) self._observers = cbook.CallbackRegistry() cnt = _api.deprecated("3.4")(property( # Not real, but close enough. lambda self: len(self._observers.callbacks['clicked']))) observers = _api.deprecated("3.4")(property( lambda self: self._observers.callbacks['clicked'])) def _clicked(self, event): if self.ignore(event) or event.button != 1 or event.inaxes != self.ax: return pclicked = self.ax.transAxes.inverted().transform((event.x, event.y)) distances = {} for i, (p, t) in enumerate(zip(self.circles, self.labels)): if (t.get_window_extent().contains(event.x, event.y) or np.linalg.norm(pclicked - p.center) < p.radius): distances[i] = np.linalg.norm(pclicked - p.center) if len(distances) > 0: closest = min(distances, key=distances.get) self.set_active(closest) def set_active(self, index): """ Select button with number *index*. Callbacks will be triggered if :attr:`eventson` is True. """ if index not in range(len(self.labels)): raise ValueError(f'Invalid RadioButton index: {index}') self.value_selected = self.labels[index].get_text() for i, p in enumerate(self.circles): if i == index: color = self.activecolor else: color = self.ax.get_facecolor() p.set_facecolor(color) if self.drawon: self.ax.figure.canvas.draw() if self.eventson: self._observers.process('clicked', self.labels[index].get_text()) def on_clicked(self, func): """ Connect the callback function *func* to button click events. Returns a connection id, which can be used to disconnect the callback. """ return self._observers.connect('clicked', func) def disconnect(self, cid): """Remove the observer with connection id *cid*.""" self._observers.disconnect(cid) class SubplotTool(Widget): """ A tool to adjust the subplot params of a `matplotlib.figure.Figure`. """ def __init__(self, targetfig, toolfig): """ Parameters ---------- targetfig : `.Figure` The figure instance to adjust. toolfig : `.Figure` The figure instance to embed the subplot tool into. """ self.figure = toolfig self.targetfig = targetfig toolfig.subplots_adjust(left=0.2, right=0.9) toolfig.suptitle("Click on slider to adjust subplot param") self._sliders = [] names = ["left", "bottom", "right", "top", "wspace", "hspace"] # The last subplot, removed below, keeps space for the "Reset" button. for name, ax in zip(names, toolfig.subplots(len(names) + 1)): ax.set_navigate(False) slider = Slider(ax, name, 0, 1, getattr(targetfig.subplotpars, name)) slider.on_changed(self._on_slider_changed) self._sliders.append(slider) toolfig.axes[-1].remove() (self.sliderleft, self.sliderbottom, self.sliderright, self.slidertop, self.sliderwspace, self.sliderhspace) = self._sliders for slider in [self.sliderleft, self.sliderbottom, self.sliderwspace, self.sliderhspace]: slider.closedmax = False for slider in [self.sliderright, self.slidertop]: slider.closedmin = False # constraints self.sliderleft.slidermax = self.sliderright self.sliderright.slidermin = self.sliderleft self.sliderbottom.slidermax = self.slidertop self.slidertop.slidermin = self.sliderbottom bax = toolfig.add_axes([0.8, 0.05, 0.15, 0.075]) self.buttonreset = Button(bax, 'Reset') self.buttonreset.on_clicked(self._on_reset) def _on_slider_changed(self, _): self.targetfig.subplots_adjust( **{slider.label.get_text(): slider.val for slider in self._sliders}) if self.drawon: self.targetfig.canvas.draw() def _on_reset(self, event): with ExitStack() as stack: # Temporarily disable drawing on self and self's sliders, and # disconnect slider events (as the subplotparams can be temporarily # invalid, depending on the order in which they are restored). stack.enter_context(cbook._setattr_cm(self, drawon=False)) for slider in self._sliders: stack.enter_context( cbook._setattr_cm(slider, drawon=False, eventson=False)) # Reset the slider to the initial position. for slider in self._sliders: slider.reset() if self.drawon: event.canvas.draw() # Redraw the subplottool canvas. self._on_slider_changed(None) # Apply changes to the target window. class Cursor(AxesWidget): """ A crosshair cursor that spans the axes and moves with mouse cursor. For the cursor to remain responsive you must keep a reference to it. Parameters ---------- ax : `matplotlib.axes.Axes` The `~.axes.Axes` to attach the cursor to. horizOn : bool, default: True Whether to draw the horizontal line. vertOn : bool, default: True Whether to draw the vertical line. useblit : bool, default: False Use blitting for faster drawing if supported by the backend. Other Parameters ---------------- **lineprops `.Line2D` properties that control the appearance of the lines. See also `~.Axes.axhline`. Examples -------- See :doc:`/gallery/widgets/cursor`. """ def __init__(self, ax, horizOn=True, vertOn=True, useblit=False, **lineprops): super().__init__(ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('draw_event', self.clear) self.visible = True self.horizOn = horizOn self.vertOn = vertOn self.useblit = useblit and self.canvas.supports_blit if self.useblit: lineprops['animated'] = True self.lineh = ax.axhline(ax.get_ybound()[0], visible=False, **lineprops) self.linev = ax.axvline(ax.get_xbound()[0], visible=False, **lineprops) self.background = None self.needclear = False def clear(self, event): """Internal event handler to clear the cursor.""" if self.ignore(event): return if self.useblit: self.background = self.canvas.copy_from_bbox(self.ax.bbox) self.linev.set_visible(False) self.lineh.set_visible(False) def onmove(self, event): """Internal event handler to draw the cursor when the mouse moves.""" if self.ignore(event): return if not self.canvas.widgetlock.available(self): return if event.inaxes != self.ax: self.linev.set_visible(False) self.lineh.set_visible(False) if self.needclear: self.canvas.draw() self.needclear = False return self.needclear = True if not self.visible: return self.linev.set_xdata((event.xdata, event.xdata)) self.lineh.set_ydata((event.ydata, event.ydata)) self.linev.set_visible(self.visible and self.vertOn) self.lineh.set_visible(self.visible and self.horizOn) self._update() def _update(self): if self.useblit: if self.background is not None: self.canvas.restore_region(self.background) self.ax.draw_artist(self.linev) self.ax.draw_artist(self.lineh) self.canvas.blit(self.ax.bbox) else: self.canvas.draw_idle() return False class MultiCursor(Widget): """ Provide a vertical (default) and/or horizontal line cursor shared between multiple axes. For the cursor to remain responsive you must keep a reference to it. Parameters ---------- canvas : `matplotlib.backend_bases.FigureCanvasBase` The FigureCanvas that contains all the axes. axes : list of `matplotlib.axes.Axes` The `~.axes.Axes` to attach the cursor to. useblit : bool, default: True Use blitting for faster drawing if supported by the backend. horizOn : bool, default: False Whether to draw the horizontal line. vertOn: bool, default: True Whether to draw the vertical line. Other Parameters ---------------- **lineprops `.Line2D` properties that control the appearance of the lines. See also `~.Axes.axhline`. Examples -------- See :doc:`/gallery/widgets/multicursor`. """ def __init__(self, canvas, axes, useblit=True, horizOn=False, vertOn=True, **lineprops): self.canvas = canvas self.axes = axes self.horizOn = horizOn self.vertOn = vertOn xmin, xmax = axes[-1].get_xlim() ymin, ymax = axes[-1].get_ylim() xmid = 0.5 * (xmin + xmax) ymid = 0.5 * (ymin + ymax) self.visible = True self.useblit = useblit and self.canvas.supports_blit self.background = None self.needclear = False if self.useblit: lineprops['animated'] = True if vertOn: self.vlines = [ax.axvline(xmid, visible=False, **lineprops) for ax in axes] else: self.vlines = [] if horizOn: self.hlines = [ax.axhline(ymid, visible=False, **lineprops) for ax in axes] else: self.hlines = [] self.connect() def connect(self): """Connect events.""" self._cidmotion = self.canvas.mpl_connect('motion_notify_event', self.onmove) self._ciddraw = self.canvas.mpl_connect('draw_event', self.clear) def disconnect(self): """Disconnect events.""" self.canvas.mpl_disconnect(self._cidmotion) self.canvas.mpl_disconnect(self._ciddraw) def clear(self, event): """Clear the cursor.""" if self.ignore(event): return if self.useblit: self.background = ( self.canvas.copy_from_bbox(self.canvas.figure.bbox)) for line in self.vlines + self.hlines: line.set_visible(False) def onmove(self, event): if self.ignore(event): return if event.inaxes not in self.axes: return if not self.canvas.widgetlock.available(self): return self.needclear = True if not self.visible: return if self.vertOn: for line in self.vlines: line.set_xdata((event.xdata, event.xdata)) line.set_visible(self.visible) if self.horizOn: for line in self.hlines: line.set_ydata((event.ydata, event.ydata)) line.set_visible(self.visible) self._update() def _update(self): if self.useblit: if self.background is not None: self.canvas.restore_region(self.background) if self.vertOn: for ax, line in zip(self.axes, self.vlines): ax.draw_artist(line) if self.horizOn: for ax, line in zip(self.axes, self.hlines): ax.draw_artist(line) self.canvas.blit() else: self.canvas.draw_idle() class _SelectorWidget(AxesWidget): def __init__(self, ax, onselect, useblit=False, button=None, state_modifier_keys=None): super().__init__(ax) self.visible = True self.onselect = onselect self.useblit = useblit and self.canvas.supports_blit self.connect_default_events() self.state_modifier_keys = dict(move=' ', clear='escape', square='shift', center='control') self.state_modifier_keys.update(state_modifier_keys or {}) self.background = None if isinstance(button, Integral): self.validButtons = [button] else: self.validButtons = button # Set to True when a selection is completed, otherwise is False self._selection_completed = False # will save the data (position at mouseclick) self._eventpress = None # will save the data (pos. at mouserelease) self._eventrelease = None self._prev_event = None self._state = set() self._default_state = set() eventpress = _api.deprecate_privatize_attribute("3.5") eventrelease = _api.deprecate_privatize_attribute("3.5") state = _api.deprecate_privatize_attribute("3.5") def set_active(self, active): super().set_active(active) if active: self.update_background(None) def update_background(self, event): """Force an update of the background.""" # If you add a call to `ignore` here, you'll want to check edge case: # `release` can call a draw event even when `ignore` is True. if not self.useblit: return # Make sure that widget artists don't get accidentally included in the # background, by re-rendering the background if needed (and then # re-re-rendering the canvas with the visible widget artists). needs_redraw = any(artist.get_visible() for artist in self.artists) with ExitStack() as stack: if needs_redraw: for artist in self.artists: stack.enter_context(artist._cm_set(visible=False)) self.canvas.draw() self.background = self.canvas.copy_from_bbox(self.ax.bbox) if needs_redraw: for artist in self.artists: self.ax.draw_artist(artist) def connect_default_events(self): """Connect the major canvas events to methods.""" self.connect_event('motion_notify_event', self.onmove) self.connect_event('button_press_event', self.press) self.connect_event('button_release_event', self.release) self.connect_event('draw_event', self.update_background) self.connect_event('key_press_event', self.on_key_press) self.connect_event('key_release_event', self.on_key_release) self.connect_event('scroll_event', self.on_scroll) def ignore(self, event): # docstring inherited if not self.active or not self.ax.get_visible(): return True # If canvas was locked if not self.canvas.widgetlock.available(self): return True if not hasattr(event, 'button'): event.button = None # Only do rectangle selection if event was triggered # with a desired button if (self.validButtons is not None and event.button not in self.validButtons): return True # If no button was pressed yet ignore the event if it was out # of the axes if self._eventpress is None: return event.inaxes != self.ax # If a button was pressed, check if the release-button is the same. if event.button == self._eventpress.button: return False # If a button was pressed, check if the release-button is the same. return (event.inaxes != self.ax or event.button != self._eventpress.button) def update(self): """Draw using blit() or draw_idle(), depending on ``self.useblit``.""" if not self.ax.get_visible() or self.ax.figure._cachedRenderer is None: return False if self.useblit: if self.background is not None: self.canvas.restore_region(self.background) else: self.update_background(None) for artist in self.artists: self.ax.draw_artist(artist) self.canvas.blit(self.ax.bbox) else: self.canvas.draw_idle() return False def _get_data(self, event): """Get the xdata and ydata for event, with limits.""" if event.xdata is None: return None, None xdata = np.clip(event.xdata, *self.ax.get_xbound()) ydata = np.clip(event.ydata, *self.ax.get_ybound()) return xdata, ydata def _clean_event(self, event): """ Preprocess an event: - Replace *event* by the previous event if *event* has no ``xdata``. - Clip ``xdata`` and ``ydata`` to the axes limits. - Update the previous event. """ if event.xdata is None: event = self._prev_event else: event = copy.copy(event) event.xdata, event.ydata = self._get_data(event) self._prev_event = event return event def press(self, event): """Button press handler and validator.""" if not self.ignore(event): event = self._clean_event(event) self._eventpress = event self._prev_event = event key = event.key or '' key = key.replace('ctrl', 'control') # move state is locked in on a button press if key == self.state_modifier_keys['move']: self._state.add('move') self._press(event) return True return False def _press(self, event): """Button press event handler.""" def release(self, event): """Button release event handler and validator.""" if not self.ignore(event) and self._eventpress: event = self._clean_event(event) self._eventrelease = event self._release(event) self._eventpress = None self._eventrelease = None self._state.discard('move') return True return False def _release(self, event): """Button release event handler.""" def onmove(self, event): """Cursor move event handler and validator.""" if not self.ignore(event) and self._eventpress: event = self._clean_event(event) self._onmove(event) return True return False def _onmove(self, event): """Cursor move event handler.""" def on_scroll(self, event): """Mouse scroll event handler and validator.""" if not self.ignore(event): self._on_scroll(event) def _on_scroll(self, event): """Mouse scroll event handler.""" def on_key_press(self, event): """Key press event handler and validator for all selection widgets.""" if self.active: key = event.key or '' key = key.replace('ctrl', 'control') if key == self.state_modifier_keys['clear']: self.clear() return for (state, modifier) in self.state_modifier_keys.items(): if modifier in key: self._state.add(state) self._on_key_press(event) def _on_key_press(self, event): """Key press event handler - for widget-specific key press actions.""" def on_key_release(self, event): """Key release event handler and validator.""" if self.active: key = event.key or '' for (state, modifier) in self.state_modifier_keys.items(): if modifier in key: self._state.discard(state) self._on_key_release(event) def _on_key_release(self, event): """Key release event handler.""" def set_visible(self, visible): """Set the visibility of our artists.""" self.visible = visible for artist in self.artists: artist.set_visible(visible) def clear(self): """Clear the selection and set the selector ready to make a new one.""" self._selection_completed = False self.set_visible(False) self.update() @property def artists(self): """Tuple of the artists of the selector.""" handles_artists = getattr(self, '_handles_artists', ()) return (self._selection_artist,) + handles_artists def set_props(self, **props): """ Set the properties of the selector artist. See the `props` argument in the selector docstring to know which properties are supported. """ artist = self._selection_artist props = cbook.normalize_kwargs(props, artist) artist.set(**props) if self.useblit: self.update() self._props.update(props) def set_handle_props(self, **handle_props): """ Set the properties of the handles selector artist. See the `handle_props` argument in the selector docstring to know which properties are supported. """ if not hasattr(self, '_handles_artists'): raise NotImplementedError("This selector doesn't have handles.") artist = self._handles_artists[0] handle_props = cbook.normalize_kwargs(handle_props, artist) for handle in self._handles_artists: handle.set(**handle_props) if self.useblit: self.update() self._handle_props.update(handle_props) class SpanSelector(_SelectorWidget): """ Visually select a min/max range on a single axis and call a function with those values. To guarantee that the selector remains responsive, keep a reference to it. In order to turn off the SpanSelector, set ``span_selector.active`` to False. To turn it back on, set it to True. Press and release events triggered at the same coordinates outside the selection will clear the selector, except when ``ignore_event_outside=True``. Parameters ---------- ax : `matplotlib.axes.Axes` onselect : callable A callback function that is called after a release event and the selection is created, changed or removed. It must have the signature:: def on_select(min: float, max: float) -> Any direction : {"horizontal", "vertical"} The direction along which to draw the span selector. minspan : float, default: 0 If selection is less than or equal to *minspan*, the selection is removed (when already existing) or cancelled. useblit : bool, default: False If True, use the backend-dependent blitting features for faster canvas updates. props : dict, optional Dictionary of `matplotlib.patches.Patch` properties. Default: ``dict(facecolor='red', alpha=0.5)`` onmove_callback : func(min, max), min/max are floats, default: None Called on mouse move while the span is being selected. span_stays : bool, default: False If True, the span stays visible after the mouse is released. Deprecated, use *interactive* instead. interactive : bool, default: False Whether to draw a set of handles that allow interaction with the widget after it is drawn. button : `.MouseButton` or list of `.MouseButton`, default: all buttons The mouse buttons which activate the span selector. handle_props : dict, default: None Properties of the handle lines at the edges of the span. Only used when *interactive* is True. See `matplotlib.lines.Line2D` for valid properties. grab_range : float, default: 10 Distance in pixels within which the interactive tool handles can be activated. drag_from_anywhere : bool, default: False If `True`, the widget can be moved by clicking anywhere within its bounds. ignore_event_outside : bool, default: False If `True`, the event triggered outside the span selector will be ignored. Examples -------- >>> import matplotlib.pyplot as plt >>> import matplotlib.widgets as mwidgets >>> fig, ax = plt.subplots() >>> ax.plot([1, 2, 3], [10, 50, 100]) >>> def onselect(vmin, vmax): ... print(vmin, vmax) >>> span = mwidgets.SpanSelector(ax, onselect, 'horizontal', ... props=dict(facecolor='blue', alpha=0.5)) >>> fig.show() See also: :doc:`/gallery/widgets/span_selector` """ @_api.rename_parameter("3.5", "rectprops", "props") @_api.rename_parameter("3.5", "span_stays", "interactive") def __init__(self, ax, onselect, direction, minspan=0, useblit=False, props=None, onmove_callback=None, interactive=False, button=None, handle_props=None, grab_range=10, drag_from_anywhere=False, ignore_event_outside=False): super().__init__(ax, onselect, useblit=useblit, button=button) if props is None: props = dict(facecolor='red', alpha=0.5) props['animated'] = self.useblit self.direction = direction self.visible = True self._extents_on_press = None # self._pressv is deprecated and we don't use it internally anymore # but we maintain it until it is removed self._pressv = None self._props = props self.onmove_callback = onmove_callback self.minspan = minspan self.grab_range = grab_range self._interactive = interactive self._edge_handles = None self.drag_from_anywhere = drag_from_anywhere self.ignore_event_outside = ignore_event_outside # Reset canvas so that `new_axes` connects events. self.canvas = None self.new_axes(ax) # Setup handles self._handle_props = { 'color': props.get('facecolor', 'r'), **cbook.normalize_kwargs(handle_props, Line2D)} if self._interactive: self._edge_order = ['min', 'max'] self._setup_edge_handles(self._handle_props) self._active_handle = None # prev attribute is deprecated but we still need to maintain it self._prev = (0, 0) rect = _api.deprecated("3.5")( property(lambda self: self._selection_artist) ) rectprops = _api.deprecated("3.5")( property(lambda self: self._props) ) active_handle = _api.deprecate_privatize_attribute("3.5") pressv = _api.deprecate_privatize_attribute("3.5") span_stays = _api.deprecated("3.5")( property(lambda self: self._interactive) ) prev = _api.deprecate_privatize_attribute("3.5") def new_axes(self, ax): """Set SpanSelector to operate on a new Axes.""" self.ax = ax if self.canvas is not ax.figure.canvas: if self.canvas is not None: self.disconnect_events() self.canvas = ax.figure.canvas self.connect_default_events() # Reset self._selection_completed = False if self.direction == 'horizontal': trans = ax.get_xaxis_transform() w, h = 0, 1 else: trans = ax.get_yaxis_transform() w, h = 1, 0 rect_artist = Rectangle((0, 0), w, h, transform=trans, visible=False, **self._props) self.ax.add_patch(rect_artist) self._selection_artist = rect_artist def _setup_edge_handles(self, props): # Define initial position using the axis bounds to keep the same bounds if self.direction == 'horizontal': positions = self.ax.get_xbound() else: positions = self.ax.get_ybound() self._edge_handles = ToolLineHandles(self.ax, positions, direction=self.direction, line_props=props, useblit=self.useblit) @property def _handles_artists(self): if self._edge_handles is not None: return self._edge_handles.artists else: return () def _set_cursor(self, enabled): """Update the canvas cursor based on direction of the selector.""" if enabled: cursor = (backend_tools.Cursors.RESIZE_HORIZONTAL if self.direction == 'horizontal' else backend_tools.Cursors.RESIZE_VERTICAL) else: cursor = backend_tools.Cursors.POINTER self.ax.figure.canvas.set_cursor(cursor) def connect_default_events(self): # docstring inherited super().connect_default_events() if getattr(self, '_interactive', False): self.connect_event('motion_notify_event', self._hover) def _press(self, event): """Button press event handler.""" self._set_cursor(True) if self._interactive and self._selection_artist.get_visible(): self._set_active_handle(event) else: self._active_handle = None if self._active_handle is None or not self._interactive: # Clear previous rectangle before drawing new rectangle. self.update() v = event.xdata if self.direction == 'horizontal' else event.ydata # self._pressv and self._prev are deprecated but we still need to # maintain them self._pressv = v self._prev = self._get_data(event) if self._active_handle is None and not self.ignore_event_outside: # when the press event outside the span, we initially set the # visibility to False and extents to (v, v) # update will be called when setting the extents self.visible = False self.extents = v, v # We need to set the visibility back, so the span selector will be # drawn when necessary (span width > 0) self.visible = True else: self.set_visible(True) return False @property def direction(self): """Direction of the span selector: 'vertical' or 'horizontal'.""" return self._direction @direction.setter def direction(self, direction): """Set the direction of the span selector.""" _api.check_in_list(['horizontal', 'vertical'], direction=direction) if hasattr(self, '_direction') and direction != self._direction: # remove previous artists self._selection_artist.remove() if self._interactive: self._edge_handles.remove() self._direction = direction self.new_axes(self.ax) if self._interactive: self._setup_edge_handles(self._handle_props) else: self._direction = direction def _release(self, event): """Button release event handler.""" self._set_cursor(False) # self._pressv is deprecated but we still need to maintain it self._pressv = None if not self._interactive: self._selection_artist.set_visible(False) if (self._active_handle is None and self._selection_completed and self.ignore_event_outside): return vmin, vmax = self.extents span = vmax - vmin if span <= self.minspan: # Remove span and set self._selection_completed = False self.set_visible(False) if self._selection_completed: # Call onselect, only when the span is already existing self.onselect(vmin, vmax) self._selection_completed = False else: self.onselect(vmin, vmax) self._selection_completed = True self.update() self._active_handle = None return False def _hover(self, event): """Update the canvas cursor if it's over a handle.""" if self.ignore(event): return if self._active_handle is not None or not self._selection_completed: # Do nothing if button is pressed and a handle is active, which may # occur with drag_from_anywhere=True. # Do nothing if selection is not completed, which occurs when # a selector has been cleared return _, e_dist = self._edge_handles.closest(event.x, event.y) self._set_cursor(e_dist <= self.grab_range) def _onmove(self, event): """Motion notify event handler.""" # self._prev are deprecated but we still need to maintain it self._prev = self._get_data(event) v = event.xdata if self.direction == 'horizontal' else event.ydata if self.direction == 'horizontal': vpress = self._eventpress.xdata else: vpress = self._eventpress.ydata # move existing span # When "dragging from anywhere", `self._active_handle` is set to 'C' # (match notation used in the RectangleSelector) if self._active_handle == 'C' and self._extents_on_press is not None: vmin, vmax = self._extents_on_press dv = v - vpress vmin += dv vmax += dv # resize an existing shape elif self._active_handle and self._active_handle != 'C': vmin, vmax = self._extents_on_press if self._active_handle == 'min': vmin = v else: vmax = v # new shape else: # Don't create a new span if there is already one when # ignore_event_outside=True if self.ignore_event_outside and self._selection_completed: return vmin, vmax = vpress, v if vmin > vmax: vmin, vmax = vmax, vmin self.extents = vmin, vmax if self.onmove_callback is not None: self.onmove_callback(vmin, vmax) return False def _draw_shape(self, vmin, vmax): if vmin > vmax: vmin, vmax = vmax, vmin if self.direction == 'horizontal': self._selection_artist.set_x(vmin) self._selection_artist.set_width(vmax - vmin) else: self._selection_artist.set_y(vmin) self._selection_artist.set_height(vmax - vmin) def _set_active_handle(self, event): """Set active handle based on the location of the mouse event.""" # Note: event.xdata/ydata in data coordinates, event.x/y in pixels e_idx, e_dist = self._edge_handles.closest(event.x, event.y) # Prioritise center handle over other handles # Use 'C' to match the notation used in the RectangleSelector if 'move' in self._state: self._active_handle = 'C' elif e_dist > self.grab_range: # Not close to any handles self._active_handle = None if self.drag_from_anywhere and self._contains(event): # Check if we've clicked inside the region self._active_handle = 'C' self._extents_on_press = self.extents else: self._active_handle = None return else: # Closest to an edge handle self._active_handle = self._edge_order[e_idx] # Save coordinates of rectangle at the start of handle movement. self._extents_on_press = self.extents def _contains(self, event): """Return True if event is within the patch.""" return self._selection_artist.contains(event, radius=0)[0] @property def extents(self): """Return extents of the span selector.""" if self.direction == 'horizontal': vmin = self._selection_artist.get_x() vmax = vmin + self._selection_artist.get_width() else: vmin = self._selection_artist.get_y() vmax = vmin + self._selection_artist.get_height() return vmin, vmax @extents.setter def extents(self, extents): # Update displayed shape self._draw_shape(*extents) if self._interactive: # Update displayed handles self._edge_handles.set_data(self.extents) self.set_visible(self.visible) self.update() class ToolLineHandles: """ Control handles for canvas tools. Parameters ---------- ax : `matplotlib.axes.Axes` Matplotlib axes where tool handles are displayed. positions : 1D array Positions of handles in data coordinates. direction : {"horizontal", "vertical"} Direction of handles, either 'vertical' or 'horizontal' line_props : dict, optional Additional line properties. See `matplotlib.lines.Line2D`. useblit : bool, default: True Whether to use blitting for faster drawing (if supported by the backend). """ def __init__(self, ax, positions, direction, line_props=None, useblit=True): self.ax = ax _api.check_in_list(['horizontal', 'vertical'], direction=direction) self._direction = direction if line_props is None: line_props = {} line_props.update({'visible': False, 'animated': useblit}) line_fun = ax.axvline if self.direction == 'horizontal' else ax.axhline self._artists = [line_fun(p, **line_props) for p in positions] @property def artists(self): return tuple(self._artists) @property def positions(self): """Positions of the handle in data coordinates.""" method = 'get_xdata' if self.direction == 'horizontal' else 'get_ydata' return [getattr(line, method)()[0] for line in self.artists] @property def direction(self): """Direction of the handle: 'vertical' or 'horizontal'.""" return self._direction def set_data(self, positions): """ Set x or y positions of handles, depending if the lines are vertical of horizontal. Parameters ---------- positions : tuple of length 2 Set the positions of the handle in data coordinates """ method = 'set_xdata' if self.direction == 'horizontal' else 'set_ydata' for line, p in zip(self.artists, positions): getattr(line, method)([p, p]) def set_visible(self, value): """Set the visibility state of the handles artist.""" for artist in self.artists: artist.set_visible(value) def set_animated(self, value): """Set the animated state of the handles artist.""" for artist in self.artists: artist.set_animated(value) def remove(self): """Remove the handles artist from the figure.""" for artist in self._artists: artist.remove() def closest(self, x, y): """ Return index and pixel distance to closest handle. Parameters ---------- x, y : float x, y position from which the distance will be calculated to determinate the closest handle Returns ------- index, distance : index of the handle and its distance from position x, y """ if self.direction == 'horizontal': p_pts = np.array([ self.ax.transData.transform((p, 0))[0] for p in self.positions ]) dist = abs(p_pts - x) else: p_pts = np.array([ self.ax.transData.transform((0, p))[1] for p in self.positions ]) dist = abs(p_pts - y) index = np.argmin(dist) return index, dist[index] class ToolHandles: """ Control handles for canvas tools. Parameters ---------- ax : `matplotlib.axes.Axes` Matplotlib axes where tool handles are displayed. x, y : 1D arrays Coordinates of control handles. marker : str, default: 'o' Shape of marker used to display handle. See `matplotlib.pyplot.plot`. marker_props : dict, optional Additional marker properties. See `matplotlib.lines.Line2D`. useblit : bool, default: True Whether to use blitting for faster drawing (if supported by the backend). """ def __init__(self, ax, x, y, marker='o', marker_props=None, useblit=True): self.ax = ax props = {'marker': marker, 'markersize': 7, 'markerfacecolor': 'w', 'linestyle': 'none', 'alpha': 0.5, 'visible': False, 'label': '_nolegend_', **cbook.normalize_kwargs(marker_props, Line2D._alias_map)} self._markers = Line2D(x, y, animated=useblit, **props) self.ax.add_line(self._markers) @property def x(self): return self._markers.get_xdata() @property def y(self): return self._markers.get_ydata() @property def artists(self): return (self._markers, ) def set_data(self, pts, y=None): """Set x and y positions of handles.""" if y is not None: x = pts pts = np.array([x, y]) self._markers.set_data(pts) def set_visible(self, val): self._markers.set_visible(val) def set_animated(self, val): self._markers.set_animated(val) def closest(self, x, y): """Return index and pixel distance to closest index.""" pts = np.column_stack([self.x, self.y]) # Transform data coordinates to pixel coordinates. pts = self.ax.transData.transform(pts) diff = pts - [x, y] dist = np.hypot(*diff.T) min_index = np.argmin(dist) return min_index, dist[min_index] _RECTANGLESELECTOR_PARAMETERS_DOCSTRING = \ r""" Parameters ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. onselect : function A callback function that is called after a release event and the selection is created, changed or removed. It must have the signature:: def onselect(eclick: MouseEvent, erelease: MouseEvent) where *eclick* and *erelease* are the mouse click and release `.MouseEvent`\s that start and complete the selection. minspanx : float, default: 0 Selections with an x-span less than or equal to *minspanx* are removed (when already existing) or cancelled. minspany : float, default: 0 Selections with an y-span less than or equal to *minspanx* are removed (when already existing) or cancelled. useblit : bool, default: False Whether to use blitting for faster drawing (if supported by the backend). props : dict, optional Properties with which the __ARTIST_NAME__ is drawn. See `matplotlib.patches.Patch` for valid properties. Default: ``dict(facecolor='red', edgecolor='black', alpha=0.2, fill=True)`` spancoords : {"data", "pixels"}, default: "data" Whether to interpret *minspanx* and *minspany* in data or in pixel coordinates. button : `.MouseButton`, list of `.MouseButton`, default: all buttons Button(s) that trigger rectangle selection. grab_range : float, default: 10 Distance in pixels within which the interactive tool handles can be activated. handle_props : dict, optional Properties with which the interactive handles (marker artists) are drawn. See the marker arguments in `matplotlib.lines.Line2D` for valid properties. Default values are defined in ``mpl.rcParams`` except for the default value of ``markeredgecolor`` which will be the same as the ``edgecolor`` property in *props*. interactive : bool, default: False Whether to draw a set of handles that allow interaction with the widget after it is drawn. state_modifier_keys : dict, optional Keyboard modifiers which affect the widget's behavior. Values amend the defaults. - "move": Move the existing shape, default: no modifier. - "clear": Clear the current shape, default: "escape". - "square": Make the shape square, default: "shift". - "center": Make the initial point the center of the shape, default: "ctrl". "square" and "center" can be combined. drag_from_anywhere : bool, default: False If `True`, the widget can be moved by clicking anywhere within its bounds. ignore_event_outside : bool, default: False If `True`, the event triggered outside the span selector will be ignored. """ @docstring.Substitution(_RECTANGLESELECTOR_PARAMETERS_DOCSTRING.replace( '__ARTIST_NAME__', 'rectangle')) class RectangleSelector(_SelectorWidget): """ Select a rectangular region of an axes. For the cursor to remain responsive you must keep a reference to it. Press and release events triggered at the same coordinates outside the selection will clear the selector, except when ``ignore_event_outside=True``. %s Examples -------- >>> import matplotlib.pyplot as plt >>> import matplotlib.widgets as mwidgets >>> fig, ax = plt.subplots() >>> ax.plot([1, 2, 3], [10, 50, 100]) >>> def onselect(eclick, erelease): ... print(eclick.xdata, eclick.ydata) ... print(erelease.xdata, erelease.ydata) >>> props = dict(facecolor='blue', alpha=0.5) >>> rect = mwidgets.RectangleSelector(ax, onselect, interactive=True, props=props) >>> fig.show() See also: :doc:`/gallery/widgets/rectangle_selector` """ _shape_klass = Rectangle @_api.rename_parameter("3.5", "maxdist", "grab_range") @_api.rename_parameter("3.5", "marker_props", "handle_props") @_api.rename_parameter("3.5", "rectprops", "props") @_api.delete_parameter("3.5", "drawtype") @_api.delete_parameter("3.5", "lineprops") def __init__(self, ax, onselect, drawtype='box', minspanx=0, minspany=0, useblit=False, lineprops=None, props=None, spancoords='data', button=None, grab_range=10, handle_props=None, interactive=False, state_modifier_keys=None, drag_from_anywhere=False, ignore_event_outside=False): super().__init__(ax, onselect, useblit=useblit, button=button, state_modifier_keys=state_modifier_keys) self.visible = True self._interactive = interactive self.drag_from_anywhere = drag_from_anywhere self.ignore_event_outside = ignore_event_outside if drawtype == 'none': # draw a line but make it invisible _api.warn_deprecated( "3.5", message="Support for drawtype='none' is deprecated " "since %(since)s and will be removed " "%(removal)s." "Use props=dict(visible=False) instead.") drawtype = 'line' self.visible = False if drawtype == 'box': if props is None: props = dict(facecolor='red', edgecolor='black', alpha=0.2, fill=True) props['animated'] = self.useblit self.visible = props.pop('visible', self.visible) self._props = props to_draw = self._shape_klass((0, 0), 0, 1, visible=False, **self._props) self.ax.add_patch(to_draw) if drawtype == 'line': _api.warn_deprecated( "3.5", message="Support for drawtype='line' is deprecated " "since %(since)s and will be removed " "%(removal)s.") if lineprops is None: lineprops = dict(color='black', linestyle='-', linewidth=2, alpha=0.5) lineprops['animated'] = self.useblit self._props = lineprops to_draw = Line2D([0, 0], [0, 0], visible=False, **self._props) self.ax.add_line(to_draw) self._selection_artist = to_draw self.minspanx = minspanx self.minspany = minspany _api.check_in_list(['data', 'pixels'], spancoords=spancoords) self.spancoords = spancoords self._drawtype = drawtype self.grab_range = grab_range if self._interactive: self._handle_props = { 'markeredgecolor': (self._props or {}).get( 'edgecolor', 'black'), **cbook.normalize_kwargs(handle_props, Line2D)} self._corner_order = ['SW', 'SE', 'NE', 'NW'] xc, yc = self.corners self._corner_handles = ToolHandles(self.ax, xc, yc, marker_props=self._handle_props, useblit=self.useblit) self._edge_order = ['W', 'S', 'E', 'N'] xe, ye = self.edge_centers self._edge_handles = ToolHandles(self.ax, xe, ye, marker='s', marker_props=self._handle_props, useblit=self.useblit) xc, yc = self.center self._center_handle = ToolHandles(self.ax, [xc], [yc], marker='s', marker_props=self._handle_props, useblit=self.useblit) self._active_handle = None self._extents_on_press = None to_draw = _api.deprecated("3.5")( property(lambda self: self._selection_artist) ) drawtype = _api.deprecate_privatize_attribute("3.5") active_handle = _api.deprecate_privatize_attribute("3.5") interactive = _api.deprecate_privatize_attribute("3.5") maxdist = _api.deprecated("3.5", name="maxdist", alternative="grab_range")( property(lambda self: self.grab_range, lambda self, value: setattr(self, "grab_range", value))) @property def _handles_artists(self): return (*self._center_handle.artists, *self._corner_handles.artists, *self._edge_handles.artists) def _press(self, event): """Button press event handler.""" # make the drawn box/line visible get the click-coordinates, # button, ... if self._interactive and self._selection_artist.get_visible(): self._set_active_handle(event) self._extents_on_press = self.extents else: self._active_handle = None if self._active_handle is None or not self._interactive: # Clear previous rectangle before drawing new rectangle. self.update() if self._active_handle is None and not self.ignore_event_outside: x = event.xdata y = event.ydata self.visible = False self.extents = x, x, y, y self.visible = True else: self.set_visible(True) return False def _release(self, event): """Button release event handler.""" if not self._interactive: self._selection_artist.set_visible(False) if (self._active_handle is None and self._selection_completed and self.ignore_event_outside): return # update the eventpress and eventrelease with the resulting extents x0, x1, y0, y1 = self.extents self._eventpress.xdata = x0 self._eventpress.ydata = y0 xy0 = self.ax.transData.transform([x0, y0]) self._eventpress.x, self._eventpress.y = xy0 self._eventrelease.xdata = x1 self._eventrelease.ydata = y1 xy1 = self.ax.transData.transform([x1, y1]) self._eventrelease.x, self._eventrelease.y = xy1 # calculate dimensions of box or line if self.spancoords == 'data': spanx = abs(self._eventpress.xdata - self._eventrelease.xdata) spany = abs(self._eventpress.ydata - self._eventrelease.ydata) elif self.spancoords == 'pixels': spanx = abs(self._eventpress.x - self._eventrelease.x) spany = abs(self._eventpress.y - self._eventrelease.y) else: _api.check_in_list(['data', 'pixels'], spancoords=self.spancoords) # check if drawn distance (if it exists) is not too small in # either x or y-direction minspanxy = (spanx <= self.minspanx or spany <= self.minspany) if (self._drawtype != 'none' and minspanxy): for artist in self.artists: artist.set_visible(False) if self._selection_completed: # Call onselect, only when the selection is already existing self.onselect(self._eventpress, self._eventrelease) self._selection_completed = False else: self.onselect(self._eventpress, self._eventrelease) self._selection_completed = True self.update() self._active_handle = None self._extents_on_press = None return False def _onmove(self, event): """Motion notify event handler.""" state = self._state | self._default_state # resize an existing shape if self._active_handle and self._active_handle != 'C': x0, x1, y0, y1 = self._extents_on_press size_on_press = [x1 - x0, y1 - y0] center = [x0 + size_on_press[0] / 2, y0 + size_on_press[1] / 2] dx = event.xdata - self._eventpress.xdata dy = event.ydata - self._eventpress.ydata # change sign of relative changes to simplify calculation # Switch variables so that only x1 and/or y1 are updated on move x_factor = y_factor = 1 if 'W' in self._active_handle: x_factor *= -1 dx *= x_factor x0 = x1 if 'S' in self._active_handle: y_factor *= -1 dy *= y_factor y0 = y1 # Keeping the center fixed if 'center' in state: if 'square' in state: # Force the same change in dx and dy if self._active_handle in ['E', 'W']: # using E, W handle we need to update dy accordingly dy = dx elif self._active_handle in ['S', 'N']: # using S, N handle, we need to update dx accordingly dx = dy else: dx = dy = max(dx, dy, key=abs) # new half-width and half-height hw = size_on_press[0] / 2 + dx hh = size_on_press[1] / 2 + dy if 'square' not in state: # cancel changes in perpendicular direction if self._active_handle in ['E', 'W']: hh = size_on_press[1] / 2 if self._active_handle in ['N', 'S']: hw = size_on_press[0] / 2 x0, x1, y0, y1 = (center[0] - hw, center[0] + hw, center[1] - hh, center[1] + hh) else: # Keeping the opposite corner/edge fixed if 'square' in state: dx = dy = max(dx, dy, key=abs) x1 = x0 + x_factor * (dx + size_on_press[0]) y1 = y0 + y_factor * (dy + size_on_press[1]) else: if self._active_handle in ['E', 'W'] + self._corner_order: x1 = event.xdata if self._active_handle in ['N', 'S'] + self._corner_order: y1 = event.ydata # move existing shape elif (self._active_handle == 'C' or (self.drag_from_anywhere and self._contains(event)) and self._extents_on_press is not None): x0, x1, y0, y1 = self._extents_on_press dx = event.xdata - self._eventpress.xdata dy = event.ydata - self._eventpress.ydata x0 += dx x1 += dx y0 += dy y1 += dy # new shape else: # Don't create a new rectangle if there is already one when # ignore_event_outside=True if self.ignore_event_outside and self._selection_completed: return center = [self._eventpress.xdata, self._eventpress.ydata] center_pix = [self._eventpress.x, self._eventpress.y] dx = (event.xdata - center[0]) / 2. dy = (event.ydata - center[1]) / 2. # square shape if 'square' in state: dx_pix = abs(event.x - center_pix[0]) dy_pix = abs(event.y - center_pix[1]) if not dx_pix: return maxd = max(abs(dx_pix), abs(dy_pix)) if abs(dx_pix) < maxd: dx *= maxd / (abs(dx_pix) + 1e-6) if abs(dy_pix) < maxd: dy *= maxd / (abs(dy_pix) + 1e-6) # from center if 'center' in state: dx *= 2 dy *= 2 # from corner else: center[0] += dx center[1] += dy x0, x1, y0, y1 = (center[0] - dx, center[0] + dx, center[1] - dy, center[1] + dy) self.extents = x0, x1, y0, y1 @property def _rect_bbox(self): if self._drawtype == 'box': x0 = self._selection_artist.get_x() y0 = self._selection_artist.get_y() width = self._selection_artist.get_width() height = self._selection_artist.get_height() return x0, y0, width, height else: x, y = self._selection_artist.get_data() x0, x1 = min(x), max(x) y0, y1 = min(y), max(y) return x0, y0, x1 - x0, y1 - y0 @property def corners(self): """Corners of rectangle from lower left, moving clockwise.""" x0, y0, width, height = self._rect_bbox xc = x0, x0 + width, x0 + width, x0 yc = y0, y0, y0 + height, y0 + height return xc, yc @property def edge_centers(self): """Midpoint of rectangle edges from left, moving anti-clockwise.""" x0, y0, width, height = self._rect_bbox w = width / 2. h = height / 2. xe = x0, x0 + w, x0 + width, x0 + w ye = y0 + h, y0, y0 + h, y0 + height return xe, ye @property def center(self): """Center of rectangle.""" x0, y0, width, height = self._rect_bbox return x0 + width / 2., y0 + height / 2. @property def extents(self): """Return (xmin, xmax, ymin, ymax).""" x0, y0, width, height = self._rect_bbox xmin, xmax = sorted([x0, x0 + width]) ymin, ymax = sorted([y0, y0 + height]) return xmin, xmax, ymin, ymax @extents.setter def extents(self, extents): # Update displayed shape self._draw_shape(extents) if self._interactive: # Update displayed handles self._corner_handles.set_data(*self.corners) self._edge_handles.set_data(*self.edge_centers) self._center_handle.set_data(*self.center) self.set_visible(self.visible) self.update() draw_shape = _api.deprecate_privatize_attribute('3.5') def _draw_shape(self, extents): x0, x1, y0, y1 = extents xmin, xmax = sorted([x0, x1]) ymin, ymax = sorted([y0, y1]) xlim = sorted(self.ax.get_xlim()) ylim = sorted(self.ax.get_ylim()) xmin = max(xlim[0], xmin) ymin = max(ylim[0], ymin) xmax = min(xmax, xlim[1]) ymax = min(ymax, ylim[1]) if self._drawtype == 'box': self._selection_artist.set_x(xmin) self._selection_artist.set_y(ymin) self._selection_artist.set_width(xmax - xmin) self._selection_artist.set_height(ymax - ymin) elif self._drawtype == 'line': self._selection_artist.set_data([xmin, xmax], [ymin, ymax]) def _set_active_handle(self, event): """Set active handle based on the location of the mouse event.""" # Note: event.xdata/ydata in data coordinates, event.x/y in pixels c_idx, c_dist = self._corner_handles.closest(event.x, event.y) e_idx, e_dist = self._edge_handles.closest(event.x, event.y) m_idx, m_dist = self._center_handle.closest(event.x, event.y) if 'move' in self._state: self._active_handle = 'C' # Set active handle as closest handle, if mouse click is close enough. elif m_dist < self.grab_range * 2: # Prioritise center handle over other handles self._active_handle = 'C' elif (c_dist > self.grab_range and e_dist > self.grab_range): # Not close to any handles if self.drag_from_anywhere and self._contains(event): # Check if we've clicked inside the region self._active_handle = 'C' else: self._active_handle = None return elif c_dist < e_dist: # Closest to a corner handle self._active_handle = self._corner_order[c_idx] else: # Closest to an edge handle self._active_handle = self._edge_order[e_idx] def _contains(self, event): """Return True if event is within the patch.""" return self._selection_artist.contains(event, radius=0)[0] @property def geometry(self): """ Return an array of shape (2, 5) containing the x (``RectangleSelector.geometry[1, :]``) and y (``RectangleSelector.geometry[0, :]``) coordinates of the four corners of the rectangle starting and ending in the top left corner. """ if hasattr(self._selection_artist, 'get_verts'): xfm = self.ax.transData.inverted() y, x = xfm.transform(self._selection_artist.get_verts()).T return np.array([x, y]) else: return np.array(self._selection_artist.get_data()) @docstring.Substitution(_RECTANGLESELECTOR_PARAMETERS_DOCSTRING.replace( '__ARTIST_NAME__', 'ellipse')) class EllipseSelector(RectangleSelector): """ Select an elliptical region of an axes. For the cursor to remain responsive you must keep a reference to it. Press and release events triggered at the same coordinates outside the selection will clear the selector, except when ``ignore_event_outside=True``. %s Examples -------- :doc:`/gallery/widgets/rectangle_selector` """ _shape_klass = Ellipse draw_shape = _api.deprecate_privatize_attribute('3.5') def _draw_shape(self, extents): x0, x1, y0, y1 = extents xmin, xmax = sorted([x0, x1]) ymin, ymax = sorted([y0, y1]) center = [x0 + (x1 - x0) / 2., y0 + (y1 - y0) / 2.] a = (xmax - xmin) / 2. b = (ymax - ymin) / 2. if self._drawtype == 'box': self._selection_artist.center = center self._selection_artist.width = 2 * a self._selection_artist.height = 2 * b else: rad = np.deg2rad(np.arange(31) * 12) x = a * np.cos(rad) + center[0] y = b * np.sin(rad) + center[1] self._selection_artist.set_data(x, y) @property def _rect_bbox(self): if self._drawtype == 'box': x, y = self._selection_artist.center width = self._selection_artist.width height = self._selection_artist.height return x - width / 2., y - height / 2., width, height else: x, y = self._selection_artist.get_data() x0, x1 = min(x), max(x) y0, y1 = min(y), max(y) return x0, y0, x1 - x0, y1 - y0 class LassoSelector(_SelectorWidget): """ Selection curve of an arbitrary shape. For the selector to remain responsive you must keep a reference to it. The selected path can be used in conjunction with `~.Path.contains_point` to select data points from an image. In contrast to `Lasso`, `LassoSelector` is written with an interface similar to `RectangleSelector` and `SpanSelector`, and will continue to interact with the axes until disconnected. Example usage:: ax = plt.subplot() ax.plot(x, y) def onselect(verts): print(verts) lasso = LassoSelector(ax, onselect) Parameters ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. onselect : function Whenever the lasso is released, the *onselect* function is called and passed the vertices of the selected path. useblit : bool, default: True Whether to use blitting for faster drawing (if supported by the backend). props : dict, optional Properties with which the line is drawn, see `matplotlib.lines.Line2D` for valid properties. Default values are defined in ``mpl.rcParams``. button : `.MouseButton` or list of `.MouseButton`, optional The mouse buttons used for rectangle selection. Default is ``None``, which corresponds to all buttons. """ @_api.rename_parameter("3.5", "lineprops", "props") def __init__(self, ax, onselect=None, useblit=True, props=None, button=None): super().__init__(ax, onselect, useblit=useblit, button=button) self.verts = None if props is None: props = dict() # self.useblit may be != useblit, if the canvas doesn't support blit. props.update(animated=self.useblit, visible=False) line = Line2D([], [], **props) self.ax.add_line(line) self._selection_artist = line @_api.deprecated("3.5", alternative="press") def onpress(self, event): self.press(event) def _press(self, event): self.verts = [self._get_data(event)] self._selection_artist.set_visible(True) @_api.deprecated("3.5", alternative="release") def onrelease(self, event): self.release(event) def _release(self, event): if self.verts is not None: self.verts.append(self._get_data(event)) self.onselect(self.verts) self._selection_artist.set_data([[], []]) self._selection_artist.set_visible(False) self.verts = None def _onmove(self, event): if self.verts is None: return self.verts.append(self._get_data(event)) self._selection_artist.set_data(list(zip(*self.verts))) self.update() class PolygonSelector(_SelectorWidget): """ Select a polygon region of an axes. Place vertices with each mouse click, and make the selection by completing the polygon (clicking on the first vertex). Once drawn individual vertices can be moved by clicking and dragging with the left mouse button, or removed by clicking the right mouse button. In addition, the following modifier keys can be used: - Hold *ctrl* and click and drag a vertex to reposition it before the polygon has been completed. - Hold the *shift* key and click and drag anywhere in the axes to move all vertices. - Press the *esc* key to start a new polygon. For the selector to remain responsive you must keep a reference to it. Parameters ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. onselect : function When a polygon is completed or modified after completion, the *onselect* function is called and passed a list of the vertices as ``(xdata, ydata)`` tuples. useblit : bool, default: False Whether to use blitting for faster drawing (if supported by the backend). props : dict, optional Properties with which the line is drawn, see `matplotlib.lines.Line2D` for valid properties. Default: ``dict(color='k', linestyle='-', linewidth=2, alpha=0.5)`` handle_props : dict, optional Artist properties for the markers drawn at the vertices of the polygon. See the marker arguments in `matplotlib.lines.Line2D` for valid properties. Default values are defined in ``mpl.rcParams`` except for the default value of ``markeredgecolor`` which will be the same as the ``color`` property in *props*. grab_range : float, default: 10 A vertex is selected (to complete the polygon or to move a vertex) if the mouse click is within *grab_range* pixels of the vertex. Examples -------- :doc:`/gallery/widgets/polygon_selector_demo` Notes ----- If only one point remains after removing points, the selector reverts to an incomplete state and you can start drawing a new polygon from the existing point. """ @_api.rename_parameter("3.5", "lineprops", "props") @_api.rename_parameter("3.5", "markerprops", "handle_props") @_api.rename_parameter("3.5", "vertex_select_radius", "grab_range") def __init__(self, ax, onselect, useblit=False, props=None, handle_props=None, grab_range=10): # The state modifiers 'move', 'square', and 'center' are expected by # _SelectorWidget but are not supported by PolygonSelector # Note: could not use the existing 'move' state modifier in-place of # 'move_all' because _SelectorWidget automatically discards 'move' # from the state on button release. state_modifier_keys = dict(clear='escape', move_vertex='control', move_all='shift', move='not-applicable', square='not-applicable', center='not-applicable') super().__init__(ax, onselect, useblit=useblit, state_modifier_keys=state_modifier_keys) self._xs, self._ys = [0], [0] if props is None: props = dict(color='k', linestyle='-', linewidth=2, alpha=0.5) props['animated'] = self.useblit self._props = props line = Line2D(self._xs, self._ys, **self._props) self.ax.add_line(line) self._selection_artist = line if handle_props is None: handle_props = dict(markeredgecolor='k', markerfacecolor=self._props.get('color', 'k')) self._handle_props = handle_props self._polygon_handles = ToolHandles(self.ax, self._xs, self._ys, useblit=self.useblit, marker_props=self._handle_props) self._active_handle_idx = -1 self.grab_range = grab_range self.set_visible(True) line = _api.deprecated("3.5")( property(lambda self: self._selection_artist) ) vertex_select_radius = _api.deprecated("3.5", name="vertex_select_radius", alternative="grab_range")( property(lambda self: self.grab_range, lambda self, value: setattr(self, "grab_range", value)) ) @property def _nverts(self): return len(self._xs) @property def _handles_artists(self): return self._polygon_handles.artists def _remove_vertex(self, i): """Remove vertex with index i.""" if (self._nverts > 2 and self._selection_completed and i in (0, self._nverts - 1)): # If selecting the first or final vertex, remove both first and # last vertex as they are the same for a closed polygon self._xs.pop(0) self._ys.pop(0) self._xs.pop(-1) self._ys.pop(-1) # Close the polygon again by appending the new first vertex to the # end self._xs.append(self._xs[0]) self._ys.append(self._ys[0]) else: self._xs.pop(i) self._ys.pop(i) if self._nverts <= 2: # If only one point left, return to incomplete state to let user # start drawing again self._selection_completed = False def _press(self, event): """Button press event handler.""" # Check for selection of a tool handle. if ((self._selection_completed or 'move_vertex' in self._state) and len(self._xs) > 0): h_idx, h_dist = self._polygon_handles.closest(event.x, event.y) if h_dist < self.grab_range: self._active_handle_idx = h_idx # Save the vertex positions at the time of the press event (needed to # support the 'move_all' state modifier). self._xs_at_press, self._ys_at_press = self._xs.copy(), self._ys.copy() def _release(self, event): """Button release event handler.""" # Release active tool handle. if self._active_handle_idx >= 0: if event.button == 3: self._remove_vertex(self._active_handle_idx) self._draw_polygon() self._active_handle_idx = -1 # Complete the polygon. elif (len(self._xs) > 3 and self._xs[-1] == self._xs[0] and self._ys[-1] == self._ys[0]): self._selection_completed = True # Place new vertex. elif (not self._selection_completed and 'move_all' not in self._state and 'move_vertex' not in self._state): self._xs.insert(-1, event.xdata) self._ys.insert(-1, event.ydata) if self._selection_completed: self.onselect(self.verts) def onmove(self, event): """Cursor move event handler and validator.""" # Method overrides _SelectorWidget.onmove because the polygon selector # needs to process the move callback even if there is no button press. # _SelectorWidget.onmove include logic to ignore move event if # _eventpress is None. if not self.ignore(event): event = self._clean_event(event) self._onmove(event) return True return False def _onmove(self, event): """Cursor move event handler.""" # Move the active vertex (ToolHandle). if self._active_handle_idx >= 0: idx = self._active_handle_idx self._xs[idx], self._ys[idx] = event.xdata, event.ydata # Also update the end of the polygon line if the first vertex is # the active handle and the polygon is completed. if idx == 0 and self._selection_completed: self._xs[-1], self._ys[-1] = event.xdata, event.ydata # Move all vertices. elif 'move_all' in self._state and self._eventpress: dx = event.xdata - self._eventpress.xdata dy = event.ydata - self._eventpress.ydata for k in range(len(self._xs)): self._xs[k] = self._xs_at_press[k] + dx self._ys[k] = self._ys_at_press[k] + dy # Do nothing if completed or waiting for a move. elif (self._selection_completed or 'move_vertex' in self._state or 'move_all' in self._state): return # Position pending vertex. else: # Calculate distance to the start vertex. x0, y0 = self._selection_artist.get_transform().transform( (self._xs[0], self._ys[0]) ) v0_dist = np.hypot(x0 - event.x, y0 - event.y) # Lock on to the start vertex if near it and ready to complete. if len(self._xs) > 3 and v0_dist < self.grab_range: self._xs[-1], self._ys[-1] = self._xs[0], self._ys[0] else: self._xs[-1], self._ys[-1] = event.xdata, event.ydata self._draw_polygon() def _on_key_press(self, event): """Key press event handler.""" # Remove the pending vertex if entering the 'move_vertex' or # 'move_all' mode if (not self._selection_completed and ('move_vertex' in self._state or 'move_all' in self._state)): self._xs, self._ys = self._xs[:-1], self._ys[:-1] self._draw_polygon() def _on_key_release(self, event): """Key release event handler.""" # Add back the pending vertex if leaving the 'move_vertex' or # 'move_all' mode (by checking the released key) if (not self._selection_completed and (event.key == self.state_modifier_keys.get('move_vertex') or event.key == self.state_modifier_keys.get('move_all'))): self._xs.append(event.xdata) self._ys.append(event.ydata) self._draw_polygon() # Reset the polygon if the released key is the 'clear' key. elif event.key == self.state_modifier_keys.get('clear'): event = self._clean_event(event) self._xs, self._ys = [event.xdata], [event.ydata] self._selection_completed = False self.set_visible(True) def _draw_polygon(self): """Redraw the polygon based on the new vertex positions.""" self._selection_artist.set_data(self._xs, self._ys) # Only show one tool handle at the start and end vertex of the polygon # if the polygon is completed or the user is locked on to the start # vertex. if (self._selection_completed or (len(self._xs) > 3 and self._xs[-1] == self._xs[0] and self._ys[-1] == self._ys[0])): self._polygon_handles.set_data(self._xs[:-1], self._ys[:-1]) else: self._polygon_handles.set_data(self._xs, self._ys) self.update() @property def verts(self): """The polygon vertices, as a list of ``(x, y)`` pairs.""" return list(zip(self._xs[:-1], self._ys[:-1])) class Lasso(AxesWidget): """ Selection curve of an arbitrary shape. The selected path can be used in conjunction with `~matplotlib.path.Path.contains_point` to select data points from an image. Unlike `LassoSelector`, this must be initialized with a starting point *xy*, and the `Lasso` events are destroyed upon release. Parameters ---------- ax : `~matplotlib.axes.Axes` The parent axes for the widget. xy : (float, float) Coordinates of the start of the lasso. useblit : bool, default: True Whether to use blitting for faster drawing (if supported by the backend). callback : callable Whenever the lasso is released, the *callback* function is called and passed the vertices of the selected path. """ def __init__(self, ax, xy, callback=None, useblit=True): super().__init__(ax) self.useblit = useblit and self.canvas.supports_blit if self.useblit: self.background = self.canvas.copy_from_bbox(self.ax.bbox) x, y = xy self.verts = [(x, y)] self.line = Line2D([x], [y], linestyle='-', color='black', lw=2) self.ax.add_line(self.line) self.callback = callback self.connect_event('button_release_event', self.onrelease) self.connect_event('motion_notify_event', self.onmove) def onrelease(self, event): if self.ignore(event): return if self.verts is not None: self.verts.append((event.xdata, event.ydata)) if len(self.verts) > 2: self.callback(self.verts) self.ax.lines.remove(self.line) self.verts = None self.disconnect_events() def onmove(self, event): if self.ignore(event): return if self.verts is None: return if event.inaxes != self.ax: return if event.button != 1: return self.verts.append((event.xdata, event.ydata)) self.line.set_data(list(zip(*self.verts))) if self.useblit: self.canvas.restore_region(self.background) self.ax.draw_artist(self.line) self.canvas.blit(self.ax.bbox) else: self.canvas.draw_idle()