综合编辑器

这是一个示例，展示如何使用Matplotlib事件处理来构建跨GUI应用程序，以与画布上的对象进行交互。

综合编辑器示例

  1. import numpy as np
  2. from matplotlib.lines import Line2D
  3. from matplotlib.artist import Artist
  4. from matplotlib.mlab import dist_point_to_segment
  7. class PolygonInteractor(object):
  8.     """
  9.     A polygon editor.
  11.     Key-bindings
  13.       't' toggle vertex markers on and off.  When vertex markers are on,
  14.           you can move them, delete them
  16.       'd' delete the vertex under point
  18.       'i' insert a vertex at point.  You must be within epsilon of the
  19.           line connecting two existing vertices
  21.     """
  23.     showverts = True
  24.     epsilon = 5  # max pixel distance to count as a vertex hit
  26.     def __init__(self, ax, poly):
  27.         if poly.figure is None:
  28.             raise RuntimeError('You must first add the polygon to a figure '
  29.                                'or canvas before defining the interactor')
  30.         self.ax = ax
  31.         canvas = poly.figure.canvas
  32.         self.poly = poly
  34.         x, y = zip(*self.poly.xy)
  35.         self.line = Line2D(x, y,
  36.                            marker='o', markerfacecolor='r',
  37.                            animated=True)
  38.         self.ax.add_line(self.line)
  40.         self.cid = self.poly.add_callback(self.poly_changed)
  41.         self._ind = None  # the active vert
  43.         canvas.mpl_connect('draw_event', self.draw_callback)
  44.         canvas.mpl_connect('button_press_event', self.button_press_callback)
  45.         canvas.mpl_connect('key_press_event', self.key_press_callback)
  46.         canvas.mpl_connect('button_release_event', self.button_release_callback)
  47.         canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
  48.         self.canvas = canvas
  50.     def draw_callback(self, event):
  51.         self.background = self.canvas.copy_from_bbox(self.ax.bbox)
  52.         self.ax.draw_artist(self.poly)
  53.         self.ax.draw_artist(self.line)
  54.         # do not need to blit here, this will fire before the screen is
  55.         # updated
  57.     def poly_changed(self, poly):
  58.         'this method is called whenever the polygon object is called'
  59.         # only copy the artist props to the line (except visibility)
  60.         vis = self.line.get_visible()
  61.         Artist.update_from(self.line, poly)
  62.         self.line.set_visible(vis)  # don't use the poly visibility state
  64.     def get_ind_under_point(self, event):
  65.         'get the index of the vertex under point if within epsilon tolerance'
  67.         # display coords
  68.         xy = np.asarray(self.poly.xy)
  69.         xyt = self.poly.get_transform().transform(xy)
  70.         xt, yt = xyt[:, 0], xyt[:, 1]
  71.         d = np.hypot(xt - event.x, yt - event.y)
  72.         indseq, = np.nonzero(d == d.min())
  73.         ind = indseq[0]
  75.         if d[ind] >= self.epsilon:
  76.             ind = None
  78.         return ind
  80.     def button_press_callback(self, event):
  81.         'whenever a mouse button is pressed'
  82.         if not self.showverts:
  83.             return
  84.         if event.inaxes is None:
  85.             return
  86.         if event.button != 1:
  87.             return
  88.         self._ind = self.get_ind_under_point(event)
  90.     def button_release_callback(self, event):
  91.         'whenever a mouse button is released'
  92.         if not self.showverts:
  93.             return
  94.         if event.button != 1:
  95.             return
  96.         self._ind = None
  98.     def key_press_callback(self, event):
  99.         'whenever a key is pressed'
  100.         if not event.inaxes:
  101.             return
  102.         if event.key == 't':
  103.             self.showverts = not self.showverts
  104.             self.line.set_visible(self.showverts)
  105.             if not self.showverts:
  106.                 self._ind = None
  107.         elif event.key == 'd':
  108.             ind = self.get_ind_under_point(event)
  109.             if ind is not None:
  110.                 self.poly.xy = np.delete(self.poly.xy,
  111.                                          ind, axis=0)
  112.                 self.line.set_data(zip(*self.poly.xy))
  113.         elif event.key == 'i':
  114.             xys = self.poly.get_transform().transform(self.poly.xy)
  115.             p = event.x, event.y  # display coords
  116.             for i in range(len(xys) - 1):
  117.                 s0 = xys[i]
  118.                 s1 = xys[i + 1]
  119.                 d = dist_point_to_segment(p, s0, s1)
  120.                 if d <= self.epsilon:
  121.                     self.poly.xy = np.insert(
  122.                         self.poly.xy, i+1,
  123.                         [event.xdata, event.ydata],
  124.                         axis=0)
  125.                     self.line.set_data(zip(*self.poly.xy))
  126.                     break
  127.         if self.line.stale:
  128.             self.canvas.draw_idle()
  130.     def motion_notify_callback(self, event):
  131.         'on mouse movement'
  132.         if not self.showverts:
  133.             return
  134.         if self._ind is None:
  135.             return
  136.         if event.inaxes is None:
  137.             return
  138.         if event.button != 1:
  139.             return
  140.         x, y = event.xdata, event.ydata
  142.         self.poly.xy[self._ind] = x, y
  143.         if self._ind == 0:
  144.             self.poly.xy[-1] = x, y
  145.         elif self._ind == len(self.poly.xy) - 1:
  146.             self.poly.xy[0] = x, y
  147.         self.line.set_data(zip(*self.poly.xy))
  149.         self.canvas.restore_region(self.background)
  150.         self.ax.draw_artist(self.poly)
  151.         self.ax.draw_artist(self.line)
  152.         self.canvas.blit(self.ax.bbox)
  155. if __name__ == '__main__':
  156.     import matplotlib.pyplot as plt
  157.     from matplotlib.patches import Polygon
  159.     theta = np.arange(0, 2*np.pi, 0.1)
  160.     r = 1.5
  162.     xs = r * np.cos(theta)
  163.     ys = r * np.sin(theta)
  165.     poly = Polygon(np.column_stack([xs, ys]), animated=True)
  167.     fig, ax = plt.subplots()
  168.     ax.add_patch(poly)
  169.     p = PolygonInteractor(ax, poly)
  171.     ax.set_title('Click and drag a point to move it')
  172.     ax.set_xlim((-2, 2))
  173.     ax.set_ylim((-2, 2))
  174.     plt.show()

下载这个示例