text: """
  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
  
  import numpy as np
  
  from . import cbook, rcParams
  from .lines import Line2D
  from .patches import Circle, Rectangle, Ellipse
  from .transforms import blended_transform_factory
  
  
  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 that is 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` subclass
          The parent figure canvas for the widget.
      active : bool
          If False, the widget does not respond to events.
      """
      def __init__(self, ax):
          self.ax = ax
          self.canvas = ax.figure.canvas
          self.cids = []
  
      def connect_event(self, event, callback):
          """
          Connect callback 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.
      """
  
      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. Accepts string.
          image : array-like or PIL image
              The image to place in the button, if not *None*.
              Supported inputs are the same as for `.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.
          """
          AxesWidget.__init__(self, 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.cnt = 0
          self.observers = {}
  
          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
  
          self._lastcolor = color
  
      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 (not self.eventson
                  or event.inaxes != self.ax):
              return
          for cid, func in self.observers.items():
              func(event)
  
      def _motion(self, event):
          if self.ignore(event):
              return
          if event.inaxes == self.ax:
              c = self.hovercolor
          else:
              c = self.color
          if c != self._lastcolor:
              self.ax.set_facecolor(c)
              self._lastcolor = 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.
          """
          cid = self.cnt
          self.observers[cid] = func
          self.cnt += 1
          return cid
  
      def disconnect(self, cid):
          """Remove the callback function with connection id *cid*."""
          try:
              del self.observers[cid]
          except KeyError:
              pass
  
  
  class Slider(AxesWidget):
      """
      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.
      """
      def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f',
                   closedmin=True, closedmax=True, slidermin=None,
                   slidermax=None, dragging=True, valstep=None,
                   orientation='horizontal', **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, optional, default: 0.5
              The slider initial position.
  
          valfmt : str, optional, default: "%1.2f"
              Used to format the slider value, fprint format string.
  
          closedmin : bool, optional, default: True
              Whether the slider interval is closed on the bottom.
  
          closedmax : bool, optional, default: True
              Whether the slider interval is closed on the top.
  
          slidermin : Slider, optional, default: None
              Do not allow the current slider to have a value less than
              the value of the Slider `slidermin`.
  
          slidermax : Slider, optional, default: None
              Do not allow the current slider to have a value greater than
              the value of the Slider `slidermax`.
  
          dragging : bool, optional, default: True
              If True the slider can be dragged by the mouse.
  
          valstep : float, optional, default: None
              If given, the slider will snap to multiples of `valstep`.
  
          orientation : {'horizontal', 'vertical'}, default: 'horizontal'
              The orientation of the slider.
  
          Notes
          -----
          Additional kwargs are passed on to ``self.poly`` which is the
          `~matplotlib.patches.Rectangle` that draws the slider knob.  See the
          `.Rectangle` documentation for valid property names (``facecolor``,
          ``edgecolor``, ``alpha``, etc.).
          """
          if ax.name == '3d':
              raise ValueError('Sliders cannot be added to 3D Axes')
  
          AxesWidget.__init__(self, ax)
  
          if slidermin is not None and not hasattr(slidermin, 'val'):
              raise ValueError("Argument slidermin ({}) has no 'val'"
                               .format(type(slidermin)))
          if slidermax is not None and not hasattr(slidermax, 'val'):
              raise ValueError("Argument slidermax ({}) has no 'val'"
                               .format(type(slidermax)))
          if orientation not in ['horizontal', 'vertical']:
              raise ValueError("Argument orientation ({}) must be either"
                               "'horizontal' or 'vertical'".format(orientation))
  
          self.orientation = orientation
          self.closedmin = closedmin
          self.closedmax = closedmax
          self.slidermin = slidermin
          self.slidermax = slidermax
          self.drag_active = False
          self.valmin = valmin
          self.valmax = valmax
          self.valstep = valstep
          valinit = self._value_in_bounds(valinit)
          if valinit is None:
              valinit = valmin
          self.val = valinit
          self.valinit = valinit
          if orientation == 'vertical':
              self.poly = ax.axhspan(valmin, valinit, 0, 1, **kwargs)
              self.hline = ax.axhline(valinit, 0, 1, color='r', lw=1)
          else:
              self.poly = ax.axvspan(valmin, valinit, 0, 1, **kwargs)
              self.vline = ax.axvline(valinit, 0, 1, color='r', lw=1)
  
          self.valfmt = valfmt
          ax.set_yticks([])
          if orientation == 'vertical':
              ax.set_ylim((valmin, valmax))
          else:
              ax.set_xlim((valmin, valmax))
          ax.set_xticks([])
          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)
          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, valfmt % 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, valfmt % valinit,
                                     transform=ax.transAxes,
                                     verticalalignment='center',
                                     horizontalalignment='left')
  
          self.cnt = 0
          self.observers = {}
  
          self.set_val(valinit)
  
      def _value_in_bounds(self, val):
          """Makes sure *val* is with given bounds."""
          if self.valstep:
              val = (self.valmin
                     + round((val - self.valmin) / self.valstep) * self.valstep)
  
          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 set_val(self, val):
          """
          Set slider value to *val*
  
          Parameters
          ----------
          val : float
          """
          xy = self.poly.xy
          if self.orientation == 'vertical':
              xy[1] = 0, val
              xy[2] = 1, val
          else:
              xy[2] = val, 1
              xy[3] = val, 0
          self.poly.xy = xy
          self.valtext.set_text(self.valfmt % val)
          if self.drawon:
              self.ax.figure.canvas.draw_idle()
          self.val = val
          if not self.eventson:
              return
          for cid, func in self.observers.items():
              func(val)
  
      def on_changed(self, func):
          """
          When the slider value is changed call *func* with the new
          slider value
  
          Parameters
          ----------
          func : callable
              Function to call when slider is changed.
              The function must accept a single float as its arguments.
  
          Returns
          -------
          cid : int
              Connection id (which can be used to disconnect *func*)
          """
          cid = self.cnt
          self.observers[cid] = func
          self.cnt += 1
          return cid
  
      def disconnect(self, cid):
          """
          Remove the observer with connection id *cid*
  
          Parameters
          ----------
          cid : int
              Connection id of the observer to be removed
          """
          try:
              del self.observers[cid]
          except KeyError:
              pass
  
      def reset(self):
          """Reset the slider to the initial value"""
          if self.val != self.valinit:
              self.set_val(self.valinit)
  
  
  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 :meth:`on_clicked` method
  
      Attributes
      ----------
      ax
          The `matplotlib.axes.Axes` the button are located in.
      labels
          A list of `matplotlib.text.Text`\ s.
      lines
          List of (line1, line2) tuples 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.
      rectangles
          A list of `matplotlib.patches.Rectangle`\ s.
      """
  
      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.
          """
          AxesWidget.__init__(self, 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.cnt = 0
          self.observers = {}
  
      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):
          """
          Directly (de)activate a check button by index.
  
          *index* is an index into the original label list
              that this object was constructed with.
              Raises ValueError if *index* is invalid.
  
          Callbacks will be triggered if :attr:`eventson` is True.
          """
          if not 0 <= index < len(self.labels):
              raise ValueError("Invalid CheckButton index: %d" % 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 not self.eventson:
              return
          for cid, func in self.observers.items():
              func(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.
          """
          cid = self.cnt
          self.observers[cid] = func
          self.cnt += 1
          return cid
  
      def disconnect(self, cid):
          """remove the observer with connection id *cid*"""
          try:
              del self.observers[cid]
          except KeyError:
              pass
  
  
  class TextBox(AxesWidget):
      """
      A GUI neutral text input box.
  
      For the text box to remain responsive you must keep a reference to it.
  
      Call :meth:`on_text_change` to be updated whenever the text changes.
  
      Call :meth:`on_submit` to be updated whenever the user hits enter or
      leaves the text entry field.
  
      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.
      """
  
      def __init__(self, ax, label, initial='',
                   color='.95', hovercolor='1', label_pad=.01):
          """
          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.
          """
          AxesWidget.__init__(self, ax)
  
          self.DIST_FROM_LEFT = .05
  
          self.params_to_disable = [key for key in rcParams if 'keymap' in key]
  
          self.text = initial
          self.label = ax.text(-label_pad, 0.5, label,
                               verticalalignment='center',
                               horizontalalignment='right',
                               transform=ax.transAxes)
          self.text_disp = self._make_text_disp(self.text)
  
          self.cnt = 0
          self.change_observers = {}
          self.submit_observers = {}
  
          # If these lines are removed, the cursor won't appear the first
          # time the box is clicked:
          self.ax.set_xlim(0, 1)
          self.ax.set_ylim(0, 1)
  
          self.cursor_index = 0
  
          # Because this is initialized, _render_cursor
          # can assume that cursor exists.
          self.cursor = self.ax.vlines(0, 0, 0)
          self.cursor.set_visible(False)
  
          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)
          ax.set_navigate(False)
          ax.set_facecolor(color)
          ax.set_xticks([])
          ax.set_yticks([])
          self.color = color
          self.hovercolor = hovercolor
  
          self._lastcolor = color
  
          self.capturekeystrokes = False
  
      def _make_text_disp(self, string):
          return self.ax.text(self.DIST_FROM_LEFT, 0.5, string,
                              verticalalignment='center',
                              horizontalalignment='left',
                              transform=self.ax.transAxes)
  
      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
  
          widthtext = self.text[:self.cursor_index]
          no_text = False
          if widthtext in ["", " ", "  "]:
              no_text = widthtext == ""
              widthtext = ","
  
          wt_disp = self._make_text_disp(widthtext)
  
          self.ax.figure.canvas.draw()
          bb = wt_disp.get_window_extent()
          inv = self.ax.transData.inverted()
          bb = inv.transform(bb)
          wt_disp.set_visible(False)
          if no_text:
              bb[1, 0] = bb[0, 0]
          # hack done
          self.cursor.set_visible(False)
  
          self.cursor = self.ax.vlines(bb[1, 0], bb[0, 1], bb[1, 1])
          self.ax.figure.canvas.draw()
  
      def _notify_submit_observers(self):
          if self.eventson:
              for cid, func in self.submit_observers.items():
                  func(self.text)
  
      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
  
              if len(key) == 1:
                  self.text = (self.text[:self.cursor_index] + key +
                               self.text[self.cursor_index:])
                  self.cursor_index += 1
              elif key == "right":
                  if self.cursor_index != len(self.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(self.text)
              elif key == "backspace":
                  if self.cursor_index != 0:
                      self.text = (self.text[:self.cursor_index - 1] +
                                   self.text[self.cursor_index:])
                      self.cursor_index -= 1
              elif key == "delete":
                  if self.cursor_index != len(self.text):
                      self.text = (self.text[:self.cursor_index] +
                                   self.text[self.cursor_index + 1:])
  
              self.text_disp.remove()
              self.text_disp = self._make_text_disp(self.text)
              self._rendercursor()
              self._notify_change_observers()
              if key == "enter":
                  self._notify_submit_observers()
  
      def set_val(self, val):
          newval = str(val)
          if self.text == newval:
              return
          self.text = newval
          self.text_disp.remove()
          self.text_disp = self._make_text_disp(self.text)
          self._rendercursor()
          self._notify_change_observers()
          self._notify_submit_observers()
  
      def _notify_change_observers(self):
          if self.eventson:
              for cid, func in self.change_observers.items():
                  func(self.text)
  
      def begin_typing(self, x):
          self.capturekeystrokes = True
          # Check for toolmanager handling the keypress
          if self.ax.figure.canvas.manager.key_press_handler_id is not None:
              # disable command keys so that the user can type without
              # command keys causing figure to be saved, etc
              self.reset_params = {}
              for key in self.params_to_disable:
                  self.reset_params[key] = rcParams[key]
                  rcParams[key] = []
          else:
              self.ax.figure.canvas.manager.toolmanager.keypresslock(self)
  
      def stop_typing(self):
          notifysubmit = False
          # Because _notify_submit_users might throw an error in the user's code,
          # we only want to call it once we've already done our cleanup.
          if self.capturekeystrokes:
              # Check for toolmanager handling the keypress
              if self.ax.figure.canvas.manager.key_press_handler_id is not None:
                  # since the user is no longer typing,
                  # reactivate the standard command keys
                  for key in self.params_to_disable:
                      rcParams[key] = self.reset_params[key]
              else:
                  toolmanager = self.ax.figure.canvas.manager.toolmanager
                  toolmanager.keypresslock.release(self)
              notifysubmit = True
          self.capturekeystrokes = False
          self.cursor.set_visible(False)
          self.ax.figure.canvas.draw()
          if notifysubmit:
              self._notify_submit_observers()
  
      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()
  
              trans = self.ax.transData
              inv = self.ax.transData.inverted()
              bb = trans.transform(inv.transform(bb))
  
              text_start = bb[0, 0]
              text_end = bb[1, 0]
  
              ratio = (x - text_start) / (text_end - text_start)
  
              if ratio < 0:
                  ratio = 0
              if ratio > 1:
                  ratio = 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
          if event.inaxes == self.ax:
              c = self.hovercolor
          else:
              c = self.color
          if c != self._lastcolor:
              self.ax.set_facecolor(c)
              self._lastcolor = 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.
          """
          cid = self.cnt
          self.change_observers[cid] = func
          self.cnt += 1
          return cid
  
      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.
          """
          cid = self.cnt
          self.submit_observers[cid] = func
          self.cnt += 1
          return cid
  
      def disconnect(self, cid):
          """Remove the observer with connection id *cid*."""
          for reg in [self.change_observers, self.submit_observers]:
              try:
                  del reg[cid]
              except KeyError:
                  pass
  
  
  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 :meth:`on_clicked` method.
  
      Attributes
      ----------
      ax
          The containing `~.axes.Axes` instance.
      activecolor
          The color of the selected button.
      labels
          A list of `~.text.Text` instances containing the button labels.
      circles
          A list of `~.patches.Circle` instances defining 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.
          """
          AxesWidget.__init__(self, 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.cnt = 0
          self.observers = {}
  
      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 0 > index >= len(self.labels):
              raise ValueError("Invalid RadioButton index: %d" % 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 not self.eventson:
              return
          for cid, func in self.observers.items():
              func(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.
          """
          cid = self.cnt
          self.observers[cid] = func
          self.cnt += 1
          return cid
  
      def disconnect(self, cid):
          """Remove the observer with connection id *cid*."""
          try:
              del self.observers[cid]
          except KeyError:
              pass
  
  
  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.targetfig = targetfig
          toolfig.subplots_adjust(left=0.2, right=0.9)
  
          self.axleft = toolfig.add_subplot(711)
          self.axleft.set_title('Click on slider to adjust subplot param')
          self.axleft.set_navigate(False)
  
          self.sliderleft = Slider(self.axleft, 'left',
                                   0, 1, targetfig.subplotpars.left,
                                   closedmax=False)
          self.sliderleft.on_changed(self.funcleft)
  
          self.axbottom = toolfig.add_subplot(712)
          self.axbottom.set_navigate(False)
          self.sliderbottom = Slider(self.axbottom,
                                     'bottom', 0, 1,
                                     targetfig.subplotpars.bottom,
                                     closedmax=False)
          self.sliderbottom.on_changed(self.funcbottom)
  
          self.axright = toolfig.add_subplot(713)
          self.axright.set_navigate(False)
          self.sliderright = Slider(self.axright, 'right', 0, 1,
                                    targetfig.subplotpars.right,
                                    closedmin=False)
          self.sliderright.on_changed(self.funcright)
  
          self.axtop = toolfig.add_subplot(714)
          self.axtop.set_navigate(False)
          self.slidertop = Slider(self.axtop, 'top', 0, 1,
                                  targetfig.subplotpars.top,
                                  closedmin=False)
          self.slidertop.on_changed(self.functop)
  
          self.axwspace = toolfig.add_subplot(715)
          self.axwspace.set_navigate(False)
          self.sliderwspace = Slider(self.axwspace, 'wspace',
                                     0, 1, targetfig.subplotpars.wspace,
                                     closedmax=False)
          self.sliderwspace.on_changed(self.funcwspace)
  
          self.axhspace = toolfig.add_subplot(716)
          self.axhspace.set_navigate(False)
          self.sliderhspace = Slider(self.axhspace, 'hspace',
                                     0, 1, targetfig.subplotpars.hspace,
                                     closedmax=False)
          self.sliderhspace.on_changed(self.funchspace)
  
          # 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')
  
          sliders = (self.sliderleft, self.sliderbottom, self.sliderright,
                     self.slidertop, self.sliderwspace, self.sliderhspace,)
  
          def func(event):
              with ExitStack() as stack:
                  # Temporarily disable drawing on self and self's sliders.
                  stack.enter_context(cbook._setattr_cm(self, drawon=False))
                  for slider in sliders:
                      stack.enter_context(
                          cbook._setattr_cm(slider, drawon=False))
                  # Reset the slider to the initial position.
                  for slider in sliders:
                      slider.reset()
              # Draw the canvas.
              if self.drawon:
                  toolfig.canvas.draw()
                  self.targetfig.canvas.draw()
  
          # during reset there can be a temporary invalid state
          # depending on the order of the reset so we turn off
          # validation for the resetting
          validate = toolfig.subplotpars.validate
          toolfig.subplotpars.validate = False
          self.buttonreset.on_clicked(func)
          toolfig.subplotpars.validate = validate
  
      def funcleft(self, val):
          self.targetfig.subplots_adjust(left=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
      def funcright(self, val):
          self.targetfig.subplots_adjust(right=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
      def funcbottom(self, val):
          self.targetfig.subplots_adjust(bottom=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
      def functop(self, val):
          self.targetfig.subplots_adjust(top=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
      def funcwspace(self, val):
          self.targetfig.subplots_adjust(wspace=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
      def funchspace(self, val):
          self.targetfig.subplots_adjust(hspace=val)
          if self.drawon:
              self.targetfig.canvas.draw()
  
  
  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, optional, default: True
          Whether to draw the horizontal line.
      vertOn : bool, optional, default: True
          Whether to draw the vertical line.
      useblit : bool, optional, 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):
          AxesWidget.__init__(self, 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.
  
      Example usage::
  
          from matplotlib.widgets import MultiCursor
          import matplotlib.pyplot as plt
          import numpy as np
  
          fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True)
          t = np.arange(0.0, 2.0, 0.01)
          ax1.plot(t, np.sin(2*np.pi*t))
          ax2.plot(t, np.sin(4*np.pi*t))
  
          multi = MultiCursor(fig.canvas, (ax1, ax2), color='r', lw=1,
                              horizOn=False, vertOn=True)
          plt.show()
  
      """
      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 is None:
              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):
          AxesWidget.__init__(self, 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
          self.artists = []
  
          if isinstance(button, Integral):
              self.validButtons = [button]
          else:
              self.validButtons = button
  
          # 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()
  
      def set_active(self, active):
          AxesWidget.set_active(self, 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 self.useblit:
              self.background = self.canvas.copy_from_bbox(self.ax.bbox)
  
      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():
              return False
          if self.useblit:
              if self.background is not None:
                  self.canvas.restore_region(self.background)
              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
          x0, x1 = self.ax.get_xbound()
          y0, y1 = self.ax.get_ybound()
          xdata = max(x0, event.xdata)
          xdata = min(x1, xdata)
          ydata = max(y0, event.ydata)
          ydata = min(y1, ydata)
          return xdata, ydata
  
      def _clean_event(self, event):
          """Clean up an event
  
          Use prev event if there is no xdata
          Limit the xdata and ydata to the axes limits
          Set the prev 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 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']:
                  for artist in self.artists:
                      artist.set_visible(False)
                  self.update()
                  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 - use 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)
  
  
  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=False`. To
      turn it back on, set `span_selector.active=True`.
  
      Parameters
      ----------
      ax : `matplotlib.axes.Axes` object
  
      onselect : func(min, max), min/max are floats
  
      direction : {"horizontal", "vertical"}
          The direction along which to draw the span selector.
  
      minspan : float, default is None
          If selection is less than *minspan*, do not call *onselect*.
  
      useblit : bool, default is False
          If True, use the backend-dependent blitting features for faster
          canvas updates.
  
      rectprops : dict, default is None
          Dictionary of `matplotlib.patches.Patch` properties.
  
      onmove_callback : func(min, max), min/max are floats, default is None
          Called on mouse move while the span is being selected.
  
      span_stays : bool, default is False
          If True, the span stays visible after the mouse is released.
  
      button : `.MouseButton` or list of `.MouseButton`
          The mouse buttons which activate the span selector.
  
      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)
      >>> rectprops = dict(facecolor='blue', alpha=0.5)
      >>> span = mwidgets.SpanSelector(ax, onselect, 'horizontal',
      ...                              rectprops=rectprops)
      >>> fig.show()
  
      See also: :doc:`/gallery/widgets/span_selector`
      """
  
      def __init__(self, ax, onselect, direction, minspan=None, useblit=False,
                   rectprops=None, onmove_callback=None, span_stays=False,
                   button=None):
  
          _SelectorWidget.__init__(self, ax, onselect, useblit=useblit,
                                   button=button)
  
          if rectprops is None:
              rectprops = dict(facecolor='red', alpha=0.5)
  
          rectprops['animated'] = self.useblit
  
          cbook._check_in_list(['horizontal', 'vertical'], direction=direction)
          self.direction = direction
  
          self.rect = None
          self.pressv = None
  
          self.rectprops = rectprops
          self.onmove_callback = onmove_callback
          self.minspan = minspan
          self.span_stays = span_stays
  
          # Needed when dragging out of axes
          self.prev = (0, 0)
  
          # Reset canvas so that `new_axes` connects events.
          self.canvas = None
          self.new_axes(ax)
  
      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()
  
          if self.direction == 'horizontal':
              trans = blended_transform_factory(self.ax.transData,
                                                self.ax.transAxes)
              w, h = 0, 1
          else:
              trans = blended_transform_factory(self.ax.transAxes,
                                                self.ax.transData)
              w, h = 1, 0
          self.rect = Rectangle((0, 0), w, h,
                                transform=trans,
                                visible=False,
                                **self.rectprops)
          if self.span_stays:
              self.stay_rect = Rectangle((0, 0), w, h,
                                         transform=trans,
                                         visible=False,
                                         **self.rectprops)
              self.stay_rect.set_animated(False)
              self.ax.add_patch(self.stay_rect)
  
          self.ax.add_patch(self.rect)
          self.artists = [self.rect]
  
      def ignore(self, event):
          # docstring inherited
          return _SelectorWidget.ignore(self, event) or not self.visible
  
      def _press(self, event):
          """on button press event"""
          self.rect.set_visible(self.visible)
          if self.span_stays:
              self.stay_rect.set_visible(False)
              # really force a draw so that the stay rect is not in
              # the blit background
              if self.useblit:
                  self.canvas.draw()
          xdata, ydata = self._get_data(event)
          if self.direction == 'horizontal':
              self.pressv = xdata
          else:
              self.pressv = ydata
  
          self._set_span_xy(event)
          return False
  
      def _release(self, event):
          """on button release event"""
          if self.pressv is None:
              return
  
          self.rect.set_visible(False)
  
          if self.span_stays:
              self.stay_rect.set_x(self.rect.get_x())
              self.stay_rect.set_y(self.rect.get_y())
              self.stay_rect.set_width(self.rect.get_width())
              self.stay_rect.set_height(self.rect.get_height())
              self.stay_rect.set_visible(True)
  
          self.canvas.draw_idle()
          vmin = self.pressv
          xdata, ydata = self._get_data(event)
          if self.direction == 'horizontal':
              vmax = xdata or self.prev[0]
          else:
              vmax = ydata or self.prev[1]
  
          if vmin > vmax:
              vmin, vmax = vmax, vmin
          span = vmax - vmin
          if self.minspan is not None and span < self.minspan:
              return
          self.onselect(vmin, vmax)
          self.pressv = None
          return False
  
      @cbook.deprecated("3.1")
      @property
      def buttonDown(self):
          return False
  
      def _onmove(self, event):
          """on motion notify event"""
          if self.pressv is None:
              return
  
          self._set_span_xy(event)
  
          if self.onmove_callback is not None:
              vmin = self.pressv
              xdata, ydata = self._get_data(event)
              if self.direction == 'horizontal':
                  vmax = xdata or self.prev[0]
              else:
                  vmax = ydata or self.prev[1]
  
              if vmin > vmax:
                  vmin, vmax = vmax, vmin
              self.onmove_callback(vmin, vmax)
  
          self.update()
          return False
  
      def _set_span_xy(self, event):
          """Setting the span coordinates"""
          x, y = self._get_data(event)
          if x is None:
              return
  
          self.prev = x, y
          if self.direction == 'horizontal':
              v = x
          else:
              v = y
  
          minv, maxv = v, self.pressv
          if minv > maxv:
              minv, maxv = maxv, minv
          if self.direction == 'horizontal':
              self.rect.set_x(minv)
              self.rect.set_width(maxv - minv)
          else:
              self.rect.set_y(minv)
              self.rect.set_height(maxv - minv)
  
  
  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
          Shape of marker used to display handle. See `matplotlib.pyplot.plot`.
      marker_props : dict
          Additional marker properties. See `matplotlib.lines.Line2D`.
      """
  
      def __init__(self, ax, x, y, marker='o', marker_props=None, useblit=True):
          self.ax = ax
          props = dict(marker=marker, markersize=7, mfc='w', ls='none',
                       alpha=0.5, visible=False, label='_nolegend_')
          props.update(marker_props if marker_props is not None else {})
          self._markers = Line2D(x, y, animated=useblit, **props)
          self.ax.add_line(self._markers)
          self.artist = self._markers
  
      @property
      def x(self):
          return self._markers.get_xdata()
  
      @property
      def y(self):
          return self._markers.get_ydata()
  
      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]
  
  
  class RectangleSelector(_SelectorWidget):
      """
      Select a rectangular region of an axes.
  
      For the cursor to remain responsive you must keep a reference to it.
  
      Example usage::
  
          import numpy as np
          import matplotlib.pyplot as plt
          from matplotlib.widgets import RectangleSelector
  
          def onselect(eclick, erelease):
              "eclick and erelease are matplotlib events at press and release."
              print('startposition: (%f, %f)' % (eclick.xdata, eclick.ydata))
              print('endposition  : (%f, %f)' % (erelease.xdata, erelease.ydata))
              print('used button  : ', eclick.button)
  
          def toggle_selector(event):
              print('Key pressed.')
              if event.key in ['Q', 'q'] and toggle_selector.RS.active:
                  print('RectangleSelector deactivated.')
                  toggle_selector.RS.set_active(False)
              if event.key in ['A', 'a'] and not toggle_selector.RS.active:
                  print('RectangleSelector activated.')
                  toggle_selector.RS.set_active(True)
  
          x = np.arange(100.) / 99
          y = np.sin(x)
          fig, ax = plt.subplots()
          ax.plot(x, y)
  
          toggle_selector.RS = RectangleSelector(ax, onselect, drawtype='line')
          fig.canvas.mpl_connect('key_press_event', toggle_selector)
          plt.show()
      """
  
      _shape_klass = Rectangle
  
      def __init__(self, ax, onselect, drawtype='box',
                   minspanx=None, minspany=None, useblit=False,
                   lineprops=None, rectprops=None, spancoords='data',
                   button=None, maxdist=10, marker_props=None,
                   interactive=False, state_modifier_keys=None):
          """
          Create a selector in *ax*.  When a selection is made, clear
          the span and call onselect with::
  
            onselect(pos_1, pos_2)
  
          and clear the drawn box/line. The ``pos_1`` and ``pos_2`` are
          arrays of length 2 containing the x- and y-coordinate.
  
          If *minspanx* is not *None* then events smaller than *minspanx*
          in x direction are ignored (it's the same for y).
  
          The rectangle is drawn with *rectprops*; default::
  
            rectprops = dict(facecolor='red', edgecolor = 'black',
                             alpha=0.2, fill=True)
  
          The line is drawn with *lineprops*; default::
  
            lineprops = dict(color='black', linestyle='-',
                             linewidth = 2, alpha=0.5)
  
          Use *drawtype* if you want the mouse to draw a line,
          a box or nothing between click and actual position by setting
  
          ``drawtype = 'line'``, ``drawtype='box'`` or ``drawtype = 'none'``.
          Drawing a line would result in a line from vertex A to vertex C in
          a rectangle ABCD.
  
          *spancoords* is one of 'data' or 'pixels'.  If 'data', *minspanx*
          and *minspanx* will be interpreted in the same coordinates as
          the x and y axis. If 'pixels', they are in pixels.
  
          *button* is a list of integers indicating which mouse buttons should
          be used for rectangle selection.  You can also specify a single
          integer if only a single button is desired.  Default is *None*,
          which does not limit which button can be used.
  
          Note, typically:
           1 = left mouse button
           2 = center mouse button (scroll wheel)
           3 = right mouse button
  
          *interactive* will draw a set of handles and allow you interact
          with the widget after it is drawn.
  
          *state_modifier_keys* are keyboard modifiers that affect the behavior
          of the widget.
  
          The defaults are:
          dict(move=' ', clear='escape', square='shift', center='ctrl')
  
          Keyboard modifiers, which:
          'move': Move the existing shape.
          'clear': Clear the current shape.
          'square': Makes the shape square.
          'center': Make the initial point the center of the shape.
          'square' and 'center' can be combined.
          """
          _SelectorWidget.__init__(self, ax, onselect, useblit=useblit,
                                   button=button,
                                   state_modifier_keys=state_modifier_keys)
  
          self.to_draw = None
          self.visible = True
          self.interactive = interactive
  
          if drawtype == 'none':  # draw a line but make it invisible
              drawtype = 'line'
              self.visible = False
  
          if drawtype == 'box':
              if rectprops is None:
                  rectprops = dict(facecolor='red', edgecolor='black',
                                   alpha=0.2, fill=True)
              rectprops['animated'] = self.useblit
              self.rectprops = rectprops
              self.to_draw = self._shape_klass((0, 0), 0, 1, visible=False,
                                               **self.rectprops)
              self.ax.add_patch(self.to_draw)
          if drawtype == 'line':
              if lineprops is None:
                  lineprops = dict(color='black', linestyle='-',
                                   linewidth=2, alpha=0.5)
              lineprops['animated'] = self.useblit
              self.lineprops = lineprops
              self.to_draw = Line2D([0, 0], [0, 0], visible=False,
                                    **self.lineprops)
              self.ax.add_line(self.to_draw)
  
          self.minspanx = minspanx
          self.minspany = minspany
  
          cbook._check_in_list(['data', 'pixels'], spancoords=spancoords)
          self.spancoords = spancoords
          self.drawtype = drawtype
  
          self.maxdist = maxdist
  
          if rectprops is None:
              props = dict(mec='r')
          else:
              props = dict(mec=rectprops.get('edgecolor', 'r'))
          self._corner_order = ['NW', 'NE', 'SE', 'SW']
          xc, yc = self.corners
          self._corner_handles = ToolHandles(self.ax, xc, yc, marker_props=props,
                                             useblit=self.useblit)
  
          self._edge_order = ['W', 'N', 'E', 'S']
          xe, ye = self.edge_centers
          self._edge_handles = ToolHandles(self.ax, xe, ye, marker='s',
                                           marker_props=props,
                                           useblit=self.useblit)
  
          xc, yc = self.center
          self._center_handle = ToolHandles(self.ax, [xc], [yc], marker='s',
                                            marker_props=props,
                                            useblit=self.useblit)
  
          self.active_handle = None
  
          self.artists = [self.to_draw, self._center_handle.artist,
                          self._corner_handles.artist,
                          self._edge_handles.artist]
  
          if not self.interactive:
              self.artists = [self.to_draw]
  
          self._extents_on_press = None
  
      def _press(self, event):
          """on button press event"""
          # make the drawed box/line visible get the click-coordinates,
          # button, ...
          if self.interactive and self.to_draw.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()
  
          if not self.interactive:
              x = event.xdata
              y = event.ydata
              self.extents = x, x, y, y
  
          self.set_visible(self.visible)
  
      def _release(self, event):
          """on button release event"""
          if not self.interactive:
              self.to_draw.set_visible(False)
  
          # update the eventpress and eventrelease with the resulting extents
          x1, x2, y1, y2 = self.extents
          self.eventpress.xdata = x1
          self.eventpress.ydata = y1
          xy1 = self.ax.transData.transform([x1, y1])
          self.eventpress.x, self.eventpress.y = xy1
  
          self.eventrelease.xdata = x2
          self.eventrelease.ydata = y2
          xy2 = self.ax.transData.transform([x2, y2])
          self.eventrelease.x, self.eventrelease.y = xy2
  
          if self.spancoords == 'data':
              xmin, ymin = self.eventpress.xdata, self.eventpress.ydata
              xmax, ymax = self.eventrelease.xdata, self.eventrelease.ydata
              # calculate dimensions of box or line get values in the right order
          elif self.spancoords == 'pixels':
              xmin, ymin = self.eventpress.x, self.eventpress.y
              xmax, ymax = self.eventrelease.x, self.eventrelease.y
          else:
              cbook._check_in_list(['data', 'pixels'],
                                   spancoords=self.spancoords)
  
          if xmin > xmax:
              xmin, xmax = xmax, xmin
          if ymin > ymax:
              ymin, ymax = ymax, ymin
  
          spanx = xmax - xmin
          spany = ymax - ymin
          xproblems = self.minspanx is not None and spanx < self.minspanx
          yproblems = self.minspany is not None and spany < self.minspany
  
          # check if drawn distance (if it exists) is not too small in
          # either x or y-direction
          if self.drawtype != 'none' and (xproblems or yproblems):
              for artist in self.artists:
                  artist.set_visible(False)
              self.update()
              return
  
          # call desired function
          self.onselect(self.eventpress, self.eventrelease)
          self.update()
  
          return False
  
      def _onmove(self, event):
          """on motion notify event if box/line is wanted"""
          # resize an existing shape
          if self.active_handle and self.active_handle != 'C':
              x1, x2, y1, y2 = self._extents_on_press
              if self.active_handle in ['E', 'W'] + self._corner_order:
                  x2 = event.xdata
              if self.active_handle in ['N', 'S'] + self._corner_order:
                  y2 = event.ydata
  
          # move existing shape
          elif (('move' in self.state or self.active_handle == 'C')
                and self._extents_on_press is not None):
              x1, x2, y1, y2 = self._extents_on_press
              dx = event.xdata - self.eventpress.xdata
              dy = event.ydata - self.eventpress.ydata
              x1 += dx
              x2 += dx
              y1 += dy
              y2 += dy
  
          # new shape
          else:
              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 self.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 self.state:
                  dx *= 2
                  dy *= 2
  
              # from corner
              else:
                  center[0] += dx
                  center[1] += dy
  
              x1, x2, y1, y2 = (center[0] - dx, center[0] + dx,
                                center[1] - dy, center[1] + dy)
  
          self.extents = x1, x2, y1, y2
  
      @property
      def _rect_bbox(self):
          if self.drawtype == 'box':
              x0 = self.to_draw.get_x()
              y0 = self.to_draw.get_y()
              width = self.to_draw.get_width()
              height = self.to_draw.get_height()
              return x0, y0, width, height
          else:
              x, y = self.to_draw.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 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)
          # 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()
  
      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.to_draw.set_x(xmin)
              self.to_draw.set_y(ymin)
              self.to_draw.set_width(xmax - xmin)
              self.to_draw.set_height(ymax - ymin)
  
          elif self.drawtype == 'line':
              self.to_draw.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'
              self._extents_on_press = self.extents
  
          # Set active handle as closest handle, if mouse click is close enough.
          elif m_dist < self.maxdist * 2:
              self.active_handle = 'C'
          elif c_dist > self.maxdist and e_dist > self.maxdist:
              self.active_handle = None
              return
          elif c_dist < e_dist:
              self.active_handle = self._corner_order[c_idx]
          else:
              self.active_handle = self._edge_order[e_idx]
  
          # Save coordinates of rectangle at the start of handle movement.
          x1, x2, y1, y2 = self.extents
          # Switch variables so that only x2 and/or y2 are updated on move.
          if self.active_handle in ['W', 'SW', 'NW']:
              x1, x2 = x2, event.xdata
          if self.active_handle in ['N', 'NW', 'NE']:
              y1, y2 = y2, event.ydata
          self._extents_on_press = x1, x2, y1, y2
  
      @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.to_draw, 'get_verts'):
              xfm = self.ax.transData.inverted()
              y, x = xfm.transform(self.to_draw.get_verts()).T
              return np.array([x, y])
          else:
              return np.array(self.to_draw.get_data())
  
  
  class EllipseSelector(RectangleSelector):
      """
      Select an elliptical region of an axes.
  
      For the cursor to remain responsive you must keep a reference to it.
  
      Example usage::
  
          import numpy as np
          import matplotlib.pyplot as plt
          from matplotlib.widgets import EllipseSelector
  
          def onselect(eclick, erelease):
              "eclick and erelease are matplotlib events at press and release."
              print('startposition: (%f, %f)' % (eclick.xdata, eclick.ydata))
              print('endposition  : (%f, %f)' % (erelease.xdata, erelease.ydata))
              print('used button  : ', eclick.button)
  
          def toggle_selector(event):
              print(' Key pressed.')
              if event.key in ['Q', 'q'] and toggle_selector.ES.active:
                  print('EllipseSelector deactivated.')
                  toggle_selector.RS.set_active(False)
              if event.key in ['A', 'a'] and not toggle_selector.ES.active:
                  print('EllipseSelector activated.')
                  toggle_selector.ES.set_active(True)
  
          x = np.arange(100.) / 99
          y = np.sin(x)
          fig, ax = plt.subplots()
          ax.plot(x, y)
  
          toggle_selector.ES = EllipseSelector(ax, onselect, drawtype='line')
          fig.canvas.mpl_connect('key_press_event', toggle_selector)
          plt.show()
      """
      _shape_klass = Ellipse
  
      def draw_shape(self, extents):
          x1, x2, y1, y2 = extents
          xmin, xmax = sorted([x1, x2])
          ymin, ymax = sorted([y1, y2])
          center = [x1 + (x2 - x1) / 2., y1 + (y2 - y1) / 2.]
          a = (xmax - xmin) / 2.
          b = (ymax - ymin) / 2.
  
          if self.drawtype == 'box':
              self.to_draw.center = center
              self.to_draw.width = 2 * a
              self.to_draw.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.to_draw.set_data(x, y)
  
      @property
      def _rect_bbox(self):
          if self.drawtype == 'box':
              x, y = self.to_draw.center
              width = self.to_draw.width
              height = self.to_draw.height
              return x - width / 2., y - height / 2., width, height
          else:
              x, y = self.to_draw.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 = subplot(111)
          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.
      button : `.MouseButton` or list of `.MouseButton`, optional
          The mouse buttons used for rectangle selection.  Default is ``None``,
          which corresponds to all buttons.
      """
  
      def __init__(self, ax, onselect=None, useblit=True, lineprops=None,
                   button=None):
          _SelectorWidget.__init__(self, ax, onselect, useblit=useblit,
                                   button=button)
          self.verts = None
          if lineprops is None:
              lineprops = dict()
          # self.useblit may be != useblit, if the canvas doesn't support blit.
          lineprops.update(animated=self.useblit, visible=False)
          self.line = Line2D([], [], **lineprops)
          self.ax.add_line(self.line)
          self.artists = [self.line]
  
      def onpress(self, event):
          self.press(event)
  
      def _press(self, event):
          self.verts = [self._get_data(event)]
          self.line.set_visible(True)
  
      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.line.set_data([[], []])
          self.line.set_visible(False)
          self.verts = None
  
      def _onmove(self, event):
          if self.verts is None:
              return
          self.verts.append(self._get_data(event))
  
          self.line.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). Hold the *ctrl* key and click
      and drag a vertex to reposition it (the *ctrl* key is not necessary if the
      polygon has already 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, optional
      lineprops : dict, optional
          The line for the sides of the polygon is drawn with the properties
          given by `lineprops`. The default is ``dict(color='k', linestyle='-',
          linewidth=2, alpha=0.5)``.
      markerprops : dict, optional
          The markers for the vertices of the polygon are drawn with the
          properties given by `markerprops`. The default is ``dict(marker='o',
          markersize=7, mec='k', mfc='k', alpha=0.5)``.
      vertex_select_radius : float, optional
          A vertex is selected (to complete the polygon or to move a vertex)
          if the mouse click is within `vertex_select_radius` pixels of the
          vertex. The default radius is 15 pixels.
  
      Examples
      --------
      :doc:`/gallery/widgets/polygon_selector_demo`
      """
  
      def __init__(self, ax, onselect, useblit=False,
                   lineprops=None, markerprops=None, vertex_select_radius=15):
          # 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')
          _SelectorWidget.__init__(self, ax, onselect, useblit=useblit,
                                   state_modifier_keys=state_modifier_keys)
  
          self._xs, self._ys = [0], [0]
          self._polygon_completed = False
  
          if lineprops is None:
              lineprops = dict(color='k', linestyle='-', linewidth=2, alpha=0.5)
          lineprops['animated'] = self.useblit
          self.line = Line2D(self._xs, self._ys, **lineprops)
          self.ax.add_line(self.line)
  
          if markerprops is None:
              markerprops = dict(mec='k', mfc=lineprops.get('color', 'k'))
          self._polygon_handles = ToolHandles(self.ax, self._xs, self._ys,
                                              useblit=self.useblit,
                                              marker_props=markerprops)
  
          self._active_handle_idx = -1
          self.vertex_select_radius = vertex_select_radius
  
          self.artists = [self.line, self._polygon_handles.artist]
          self.set_visible(True)
  
      def _press(self, event):
          """Button press event handler"""
          # Check for selection of a tool handle.
          if ((self._polygon_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.vertex_select_radius:
                  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[:], self._ys[:]
  
      def _release(self, event):
          """Button release event handler"""
          # Release active tool handle.
          if self._active_handle_idx >= 0:
              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._polygon_completed = True
  
          # Place new vertex.
          elif (not self._polygon_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._polygon_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._polygon_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._polygon_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.line.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.vertex_select_radius:
                  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._polygon_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._polygon_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._polygon_completed = False
              self.set_visible(True)
  
      def _draw_polygon(self):
          """Redraw the polygon based on the new vertex positions."""
          self.line.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._polygon_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.
      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):
          AxesWidget.__init__(self, 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()
  