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, int): 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 __init__(self, ax, name, data, wdlength, min_wdlength): """ Create a slider from *valmin* to *valmax* in axes *ax* """ AxesWidget.__init__(self, ax) self.wdlength = wdlength self.min_wdlength = min_wdlength self.voffset = 0 self.xmax = len(data) self.xmin = max(0, self.xmax-self.wdlength) self.ymax = np.max(data.high[self.xmin : self.xmax].values) + self.voffset self.ymin = np.min(data.low[self.xmin : self.xmax].values) - self.voffset self.ax = ax self.cnt = 0 self.observers = {} self.data = data self.name = name ax.set_xlim((self.xmin, self.xmax)) ax.set_ylim((self.ymin, self.ymax)) self.a1, self.a2 = candlestick2(ax, data.open.tolist()[:self.xmax], data.close.tolist()[:self.xmax], data.high.tolist()[:self.xmax], data.low.tolist()[:self.xmax], 0.6, 'r', 'g') self.connect_event('key_release_event', self.keyrelease)
def __init__(self, ax, label, image=None, color='0.85', hovercolor='0.95'): 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_axis_bgcolor(color) ax.set_xticks([]) ax.set_yticks([]) # self.ax.spines['top'].set_visible(False) # self.ax.spines['right'].set_visible(False) # self.ax.spines['bottom'].set_visible(False) # self.ax.spines['left'].set_visible(False) self.color = color self.hovercolor = hovercolor self._lastcolor = color
def __init__(self, ax, scrollbarSize=1.0, thumbSize=0.3, position=0.0, callback=None): AxesWidget.__init__(self, ax) self.ax = ax self.ax.get_xaxis().set_visible(False) self.ax.get_yaxis().set_visible(False) self.ax.set_ylim((0, scrollbarSize + thumbSize)) self.scrollbarSize = scrollbarSize self.scrollPage = (self.scrollbarSize / 20) self.thumbSize = thumbSize self.position = position self.callback = callback xx = self.ax.get_xlim() width = xx[1]-xx[0] height = self.thumbSize self.thumb = patches.Rectangle((xx[0], self.position), width, height, alpha=1.0, color='gray') self.ax.add_patch(self.thumb) self.bbox = self.thumb.get_bbox() self.drag_active = False self.drag_startY = 0 self.ax.edgecolor = 'blue' self.ax.set_facecolor('0.90') self.connect_event('button_press_event', self.onPress) self.connect_event('button_release_event', self.onRelease) self.connect_event('motion_notify_event', self.onMotion)
def __init__(self, ax, horizOn=True, vertOn=True, useblit=False, **lineprops): """ Add a cursor to *ax*. If ``useblit=True``, use the backend- dependent blitting features for faster updates (GTKAgg only for now). *lineprops* is a dictionary of line properties. .. plot :: mpl_examples/widgets/cursor.py """ # TODO: Is the GTKAgg limitation still true? 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 self.moved = False 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 __init__(self, ax, labels, active=0, activecolor='blue'): """ Add radio buttons to :class:`matplotlib.axes.Axes` instance *ax* *labels* A len(buttons) list of labels as strings *active* The index into labels for the button that is active *activecolor* The color of the button when clicked """ 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 # defaul to hard-coded value if the radius becomes too large if (circle_radius > 0.05): 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 __init__(self, ax, is_closed=False, max_points=None, line_kw=None, circle_kw=None): AxesWidget.__init__(self, ax) self.visible = True self.observers = {} self.release_observers = {} self.cid = 0 self.xs = [] self.ys = [] kw = line_kw if line_kw is not None else {} self.line = Line2D(self.xs, self.ys, **kw) self.ax.add_artist(self.line) self.circle_kw = dict(radius=5, alpha=0.5) if circle_kw: self.circle_kw.update(circle_kw) self.circles = [] self.is_closed = is_closed self.max_points = max_points self.moving_ci = None self.connect_event('button_press_event', self._press) self.connect_event('button_release_event', self._release) self.connect_event('motion_notify_event', self._motion)
def __init__(self, ax, labels, active=0, activecolor='blue', size=49, orientation="vertical", **kwargs): """ 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. size : float Size of the radio buttons orientation : str The orientation of the buttons: 'vertical' (default), or 'horizontal'. Further parameters are passed on to `Legend`. """ AxesWidget.__init__(self, ax) self.activecolor = activecolor axcolor = ax.get_facecolor() self.value_selected = None ax.set_xticks([]) ax.set_yticks([]) ax.set_navigate(False) circles = [] for i, label in enumerate(labels): if i == active: self.value_selected = label facecolor = activecolor else: facecolor = axcolor p = ax.scatter([], [], s=size, marker="o", edgecolor='black', facecolor=facecolor) circles.append(p) if orientation == "horizontal": kwargs.update(ncol=len(labels), mode="expand") kwargs.setdefault("frameon", False) self.box = ax.legend(circles, labels, loc="center", **kwargs) self.labels = self.box.texts self.circles = self.box.legendHandles for c in self.circles: c.set_picker(5) self.cnt = 0 self.observers = {} self.connect_event('pick_event', self._clicked)
def __init__(self, ax, name, data, wdlength, min_wdlength): """ Create a slider from *valmin* to *valmax* in axes *ax* """ AxesWidget.__init__(self, ax) self.wdlength = wdlength self.min_wdlength = min_wdlength self.voffset = 0 self.xmax = len(data) self.xmin = max(0, self.xmax - self.wdlength) self.ymax = np.max( data.high[self.xmin:self.xmax].values) + self.voffset self.ymin = np.min(data.low[self.xmin:self.xmax].values) - self.voffset self.ax = ax self.cnt = 0 self.observers = {} self.data = data self.name = name ax.set_xlim((self.xmin, self.xmax)) ax.set_ylim((self.ymin, self.ymax)) self.a1, self.a2 = candlestick2(ax, data.open.tolist()[:self.xmax], data.close.tolist()[:self.xmax], data.high.tolist()[:self.xmax], data.low.tolist()[:self.xmax], 0.6, 'r', 'g') self.connect_event('key_release_event', self.keyrelease)
def __init__(self, ax, is_closed=False, max_points=None, grows=True, shrinks=True, line_kw=None, circle_kw=None): AxesWidget.__init__(self, ax) Actionable.__init__(self) self.visible = True self.observers = {} self.release_observers = {} self.cid = 0 self.xs = [] self.ys = [] kw = line_kw if line_kw is not None else {} self.line, = self.ax.plot(self.xs, self.ys, **kw) self.circle_kw = circle_kw if circle_kw is not None else {} self.circles = [] self.moving_ci = None self.is_closed = is_closed self.max_points = max_points self._lclick_cids = None self.grows = grows self._rclick_cids = None self._can_shrink = False self.shrinks = shrinks self.connect_event('button_press_event', self._left_press), self.connect_event('button_release_event', self._release), self.connect_event('motion_notify_event', self._motion),
def __init__( self, parent, useblit=False, snapDist=5, snapType={ 'Segments': False, 'SegmentEnds': False, 'Origin': True, 'Grid': True, 'Centers': True }): self.parent = parent self.doc = self.parent.doc self.ax = self.parent.plt self.canvas = self.parent.canvas self.snapDist = snapDist self.snapType = self.setSnapType(snapType) SnaptoCursor.snapping = False AxesWidget.__init__(self, self.ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('draw_event', self.clear) self.useblit = useblit and self.canvas.supports_blit self.cursor, = self.ax.plot(0, 0, 'rx', animated=self.useblit) self.cursor.set_visible(False) self.visible = True self.background = None self.needclear = False
def __init__(self, ax, s='', allowed_chars=None, type=str, **text_kwargs): AxesWidget.__init__(self, ax) self.ax.set_navigate(False) self.ax.set_yticks([]) self.ax.set_xticks([]) self.type = type self.allowed_chars = allowed_chars self.value = self.type(s) self.text = self.ax.text(0.025, 0.2, s, transform=self.ax.transAxes, **text_kwargs) self._cid = None self._cursor = None self._cursorpos = len(self.text.get_text()) self.old_callbacks = {} self.cnt = 0 self.observers = {} self.exit_cnt = 0 self.exit_observers = {} self.connect_event('button_press_event', self._mouse_activate)
def __init__(self, ax, labels, marker='$-$', keep_color=False, size=49, orientation="vertical", **kwargs): """ 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... marker : str Changes can be made according to matplotlib.markers selection keep_color : Bool if True button press does nothing else button color turns on/off size : float Size of the radio buttons orientation : str The orientation of the buttons: 'vertical' (default), or 'horizontal'. Further parameters are passed on to `Legend`. """ AxesWidget.__init__(self, ax) self.value_selected = None self.keep_color = keep_color ax.set_xticks([]) ax.set_yticks([]) ax.set_navigate(False) self.circles = [] for i, label in enumerate(labels): if i: self.value_selected = label facecolor = 'C' + str(i % 10) else: facecolor = 'C' + str(i % 10) p = ax.scatter([], [], s=size, marker=marker, edgecolor='black', facecolor=facecolor) self.circles.append(p) if orientation == "horizontal": kwargs.update(ncol=len(labels), mode="expand") kwargs.setdefault("frameon", False) self.box = ax.legend(self.circles, labels, loc="center", **kwargs) self.labels = self.box.texts self.circles = self.box.legendHandles for c in self.circles: c.set_picker(5) self.cnt = 0 self.observers = {} self.connect_event('pick_event', self._clicked)
def __init__(self, ax, txt): AxesWidget.__init__(self, ax) self.t = txt self.connect_event('button_press_event', self._clicked) self._prev_color = '' self.cnt = 0 self.observers = {} ax.set_navigate(False)
def __init__(self, ax, callback=None, useblit=True): AxesWidget.__init__(self, ax) self.useblit = useblit and self.canvas.supports_blit self.verts = [] self.drawing = False self.line = None self.callback = callback self.last_click_time = time.time() self.connect_event('button_press_event', self.onpress) self.connect_event('motion_notify_event', self.onmove)
def __init__(self, ax, pos, **kwargs): AxesWidget.__init__(self, ax) self.cursor = Cursor(ax, useblit=True, **kwargs) self.connect_event('button_press_event', self._update) self.connect_event('button_release_event', self._update) self.cnt = 0 self.observers = {} self.drag_active = False self.pos = pos
def __init__(self, vertex_list, ax, channels, name=None): AxesWidget.__init__(self, ax) self.channels = channels self.name = name self.region = '?' self.gate_type = self.__class__.__name__ self._spawned_vertex_list = [vert.spawn(self.ax, channels) for vert in vertex_list] [svertex.add_callback(self.handle_vertex_event) for svertex in self._spawned_vertex_list] self.create_artist() self.activate()
def __init__(self, ax, lineprops=None, **kwargs): """ Add a bar to *ax*. *lineprops* is a dictionary of line properties. """ AxesWidget.__init__(self, ax) if lineprops is None: lineprops = dict(color='#e66101', lw=2) self.linev = ax.axvline(0, 0, 1, visible=False, **lineprops) self.background = None self.needclear = False self.connect_event('draw_event', self.clear)
def __init__(self, ax, pixels): AxesWidget.__init__(self, ax) self.pixels = pixels self.image = self.ax.imshow(self.pixels, aspect='auto', interpolation='none', vmin=0, vmax=1) self.l = None self.observers = {} self.cid = 0
def __init__(self, ax, x, y, horizOn=True, vertOn=True, useblit=False, **lineprops): AxesWidget.__init__(self, ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('button_press_event', self.onclick) 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.marker, = ax.plot(0, 0, marker='o', visible=False, color='red', markersize=4) self.background = None self.needclear = False self.x = x self.y = y # text location in axes coords self.txt = ax.text(0.25, 0.95, '', transform=ax.transAxes, bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 0.8, 0.8))) self.gradtxt = ax.text(0.25, 0.8, '', transform=ax.transAxes, bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 0.8, 0.8))) self.positions = [] self.lines = []
def __init__(self, ax, radius, **circprops): AxesWidget.__init__(self, ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('draw_event', self.storebg) circprops['animated'] = True circprops['radius'] = radius self.circ = plt.Circle((0,0), **circprops) self.ax.add_artist(self.circ) self.background = None
def __init__(self, ax, radius, **circprops): AxesWidget.__init__(self, ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('draw_event', self.storebg) circprops['animated'] = True circprops['radius'] = radius self.circ = plt.Circle((0, 0), **circprops) self.ax.add_artist(self.circ) self.background = None
def __init__(self, ax, pixels): AxesWidget.__init__(self, ax) Actionable.__init__(self) self.pixels = pixels self.image = self.ax.imshow(self.pixels, aspect='auto', interpolation='none', vmin=0, vmax=1) self.l = None self.observers = {} self.cid = 0
def __init__(self, ax, track_x=True, track_y=True, show_coord=True, text_format="(%.2f, %.2f)", col='green', useblit=True, show_drag=False, **lineprops): AxesWidget.__init__(self, ax) self.connect_event('motion_notify_event', self.onmove) self.connect_event('draw_event', self.clear) if show_drag: self.connect_event('button_press_event', self.on_press) self.connect_event('button_release_event', self.on_release) self.visible = True self.horizOn = track_y self.vertOn = track_x self.drag_on = show_drag self.show_coord = show_coord self.text_format = text_format self.useblit = useblit and self.canvas.supports_blit if self.useblit: lineprops['animated'] = True if 'color' not in lineprops: lineprops['color'] = col self.lineh = ax.axhline(ax.get_ybound()[0], visible=False, **lineprops) self.linev = ax.axvline(ax.get_xbound()[0], visible=False, **lineprops) self.text = ax.text(ax.get_xbound()[0], ax.get_ybound()[0], '', fontsize=8, color=col, visible=False) self.area = patches.Rectangle((0, 0), 0, 0, fc=col, ec=None, alpha=0.2, visible=False) self.ax.add_patch(self.area) self._press = None self.background = None self.needclear = False
def __init__(self, ax, label, image=None, color='0.85', hovercolor='0.95'): """ Parameters ---------- ax : matplotlib.axes.Axes The :class:`matplotlib.axes.Axes` instance the button will be placed into. label : str The button text. Accepts string. image : array, mpl image, Pillow Image The image to place in the button, if not *None*. Can be any legal arg to imshow (numpy array, matplotlib Image instance, or Pillow Image). 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, fontsize=13) 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.isIterating = False self.deleteFunc = None self.color = color self.hovercolor = hovercolor self._lastcolor = color
def __init__(self, ax, name, label, valmin, valmax, valinit=0.5, width=1, valfmt='%1.2f', time_index = None, closedmin=True, closedmax=True, slidermin=None, slidermax=None, drag_enabled=True, **kwargs): """ Create a slider from *valmin* to *valmax* in axes *ax* *valinit* The slider initial position *label* The slider label *valfmt* Used to format the slider value *closedmin* and *closedmax* Indicate whether the slider interval is closed *slidermin* and *slidermax* Used to constrain the value of this slider to the values of other sliders. additional kwargs are passed on to ``self.poly`` which is the :class:`matplotlib.patches.Rectangle` which draws the slider knob. See the :class:`matplotlib.patches.Rectangle` documentation valid property names (e.g., *facecolor*, *edgecolor*, *alpha*, ...) """ AxesWidget.__init__(self, ax) self.label = ax.text(-0.02, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right') self.valtext = None self.poly = None self.reinit(valmin, valmax, valinit, width, valfmt, time_index, **kwargs) self.name = name self.cnt = 0 self.closedmin = closedmin self.closedmax = closedmax self.slidermin = slidermin self.slidermax = slidermax self.drag_active = False self.drag_enabled = drag_enabled self.observers = {} ax.set_yticks([]) #ax.set_xticks([]) # disable ticks ax.set_navigate(False) self._connect()
def __init__(self, ax, oncreated=None, lineprops=None): AxesWidget.__init__(self, ax) self.oncreated = oncreated self.verts = None if lineprops is None: lineprops = dict() self.line = pl.Line2D([], [], **lineprops) self.line.set_visible(False) self.ax.add_line(self.line) self.connect_event('button_press_event', self.onpress) # self.connect_event('button_release_event', self.onrelease) self.connect_event('motion_notify_event', self.onmove)
def __init__(self, coordinates, ax, callback_list=None): AxesWidget.__init__(self, ax) self.add_callback(callback_list) self.selected = False self.coordinates = tuple([c if c is not None else 0.5 for c in coordinates]) # Replaces all Nones with 0.5 self.trackx = coordinates[0] is not None self.tracky = coordinates[1] is not None if not self.trackx and not self.tracky: raise Exception('Mode not supported') self.artist = None self.create_artist() self.connect_event('pick_event', lambda event: self.pick(event)) self.connect_event('motion_notify_event', lambda event: self.motion_notify_event(event)) # self.connect_event('button_press_event', lambda event : self.mouse_button_press(event)) self.connect_event('button_release_event', lambda event: self.mouse_button_release(event))
def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f', closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, **kwargs): AxesWidget.__init__(self, ax) self.valmin = valmin self.valmax = valmax self.val = valinit self.valinit = valinit self.poly = ax.axhspan(valmin, valinit, 0, 1, **kwargs) self.hline = ax.axhline(valinit, 0, 1, color='r', lw=1) self.valfmt = valfmt ax.set_xticks([]) ax.set_ylim((valmin, valmax)) ax.set_yticks([]) ax.set_navigate(False) self.connect_event('button_press_event', self._update) self.connect_event('button_release_event', self._update) if dragging: self.connect_event('motion_notify_event', self._update) self.label = ax.text(0.5, 1.03, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='center') self.valtext = ax.text(0.5, -0.03, valfmt % valinit, transform=ax.transAxes, verticalalignment='center', horizontalalignment='center') self.cnt = 0 self.observers = {} self.closedmin = closedmin self.closedmax = closedmax self.slidermin = slidermin self.slidermax = slidermax self.drag_active = False
def __init__(self, ax, name, wdlength, min_wdlength): """ Create a slider from *valmin* to *valmax* in axes *ax* """ AxesWidget.__init__(self, ax) self.name = name self.wdlength = wdlength self.min_wdlength = min_wdlength self.voffset = 0 self.connect() self.plotters = { } # 当前显示的范围。 #self.xmax = len(data) #self.xmin = max(0, self.xmax-self.wdlength) #self.ymax = np.max(data.high[self.xmin : self.xmax].values) + self.voffset #self.ymin = np.min(data.low[self.xmin : self.xmax].values) - self.voffset self.cnt = 0 self.observers = {}
def __init__(self, ax, dx_frac=0.05, **rect_kw): self.rects = {} # AxesWidget sets active=True, so rects needs to exist AxesWidget.__init__(self, ax) self.visible = True self.observers = {} self.cid = 0 self.active_pick = None kw = dict( facecolor='gray', edgecolor='none', alpha=0.5, picker=5, ) kw.update(rect_kw) self._make_rects(dx_frac, kw) self.connect_event('pick_event', self._pick), self.connect_event('button_release_event', self._release), self.connect_event('motion_notify_event', self._motion),
def __init__(self, ax, callonangle=None, callonmove=None, **lineprops): """ Add an AngleMeasurement widget to *ax*. *ax* : matplotlib.axes.Axes *lineprops* is a dictionary of line properties. """ AxesWidget.__init__(self, ax) # Connect signals self.connect_event('button_press_event', self.on_press) self.connect_event('button_release_event', self.on_release) self.connect_event('motion_notify_event', self.on_motion) # Call functions self.callonangle = callonangle self.callonmove = callonmove # Variables self.visible = False self.angle = 0 self.point1_xy = [0, 0] self.point2_xy = [0, 0] self.xLine = [0, 0] self.yLine = [0, 0] self.dx = 0 self.dy = 0 if lineprops: self.line = matplotlib.axes.Axes.plot(ax, self.xLine, self.yLine, '', **lineprops) else: self.line = matplotlib.axes.Axes.plot(ax, self.xLine, self.yLine, 'r-') # line is a list of matplotlib.lines.Line2D self.line[0].set_linewidth(3) self.line[0].set_visible(self.visible) self.needclear = False
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 __init__(self, ax, dx_frac=0.05, **rect_kw): self.rects = {} # AxesWidget sets active=True, so rects needs to exist AxesWidget.__init__(self, ax) Actionable.__init__(self) self.visible = True self.observers = {} self.cid = 0 self.active_pick = None kw = dict( facecolor='gray', edgecolor='none', alpha=0.5, picker=5, ) kw.update(rect_kw) self._make_rects(dx_frac, kw) self.connect_event('pick_event', self._pick), self.connect_event('button_release_event', self._release), self.connect_event('motion_notify_event', self._motion),
def __init__(self, ax, label, image=None, color="0.85", hovercolor="0.95"): 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_axis_bgcolor(color) ax.set_xticks([]) ax.set_yticks([]) self.color = color self.hovercolor = hovercolor self._lastcolor = color
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, **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 Indicate whether the slider interval is closed on the bottom. closedmax : bool, optional, default: True Indicate 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`. Notes ----- Additional kwargs are passed on to ``self.poly`` which is the :class:`~matplotlib.patches.Rectangle` that draws the slider knob. See the :class:`~matplotlib.patches.Rectangle` documentation for valid property names (e.g., `facecolor`, `edgecolor`, `alpha`). """ 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))) 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 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([]) 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) self.label = ax.text(0.5, -0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='center') self.mintext = ax.text(-0.02, 0.5, valfmt % valmin, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right') self.maxtext = ax.text(1.02, 0.5, valfmt % valmax, transform=ax.transAxes, verticalalignment='center', horizontalalignment='left') self.valtext = ax.text(0.5, 0.45, valfmt % valinit, transform=ax.transAxes, verticalalignment='center', horizontalalignment='center', weight='bold') self.cnt = 0 self.observers = {} self.set_val(valinit)
def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f', closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, label_pos=(0.5, -0.005), valtext_pos=(0.5, 1.005), **kwargs): """ Create a slider from *valmin* to *valmax* in axes *ax*. Additional kwargs are passed on to ``self.poly`` which is the :class:`matplotlib.patches.Rectangle` which draws the slider knob. See the :class:`matplotlib.patches.Rectangle` documentation valid property names (e.g., *facecolor*, *edgecolor*, *alpha*, ...). 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 The slider initial position valfmt : str Used to format the slider value, fprint format string closedmin : bool Indicate whether the slider interval is closed on the bottom closedmax : bool Indicate whether the slider interval is closed on the top slidermin : Slider or None Do not allow the current slider to have a value less than `slidermin` slidermax : Slider or None Do not allow the current slider to have a value greater than `slidermax` dragging : bool if the slider can be dragged by the mouse """ AxesWidget.__init__(self, ax) self.valmin = valmin self.valmax = valmax self.val = valinit self.valinit = valinit self.poly = ax.axhspan(valmin, valinit, 0, 1, **kwargs) self.hline = ax.axhline(valinit, 0, 1, color='r', lw=1) self.valfmt = valfmt ax.set_xticks([]) ax.set_ylim((valmin, valmax)) ax.set_yticks([]) ax.set_navigate(False) self.connect_event('button_press_event', self._update) self.connect_event('button_release_event', self._update) if dragging: self.connect_event('motion_notify_event', self._update) self.label = ax.text(*label_pos, label, transform=ax.transAxes, verticalalignment='top', horizontalalignment='center', rotation=90) self.valtext = ax.text(*valtext_pos, valfmt % valinit, transform=ax.transAxes, verticalalignment='bottom', horizontalalignment='center', rotation=90) self.cnt = 0 self.observers = {} self.closedmin = closedmin self.closedmax = closedmax self.slidermin = slidermin self.slidermax = slidermax self.drag_active = False
def __init__(self, ax, orig_line, cropper, **opts): AxesWidget.__init__(self, ax) self.orig_line = orig_line self.cropper = cropper self.line, = ax.plot([], [], transform=self.ax.transAxes, **opts) self.orig_line.on_release(self.update)
def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f', closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, **kwargs): """ Create a slider from *valmin* to *valmax* in axes *ax* *valinit* The slider initial position *label* The slider label *valfmt* Used to format the slider value *closedmin* and *closedmax* Indicate whether the slider interval is closed *slidermin* and *slidermax* Used to constrain the value of this slider to the values of other sliders. additional kwargs are passed on to ``self.poly`` which is the :class:`matplotlib.patches.Rectangle` which draws the slider knob. See the :class:`matplotlib.patches.Rectangle` documentation valid property names (e.g., *facecolor*, *edgecolor*, *alpha*, ...) """ AxesWidget.__init__(self, ax) self.valmin = valmin self.valmax = valmax self.val = valinit self.valinit = valinit self.poly = ax.axhspan(valmin,valinit,0,1, **kwargs) self.hline = ax.axhline(valinit,0,1, color='r', lw=1) self.valfmt=valfmt ax.set_yticks([]) ax.set_ylim((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) 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') self.cnt = 0 self.observers = {} self.closedmin = closedmin self.closedmax = closedmax self.slidermin = slidermin self.slidermax = slidermax self.drag_active = False
def __init__(self, ax, im): AxesWidget.__init__(self, ax) self.cbar = colorbar_factory(ax, im) self.fmt = self.cbar.formatter = OffsetFormatter() self.ax.yaxis.set_visible(True)
def __init__(self, ax, s='', allowed_chars=None, type=str, enter_callback=None, **text_kwargs): """ Editable text box Creates a mouse-click callback such that clicking on the text box will activate the cursor. *WARNING* Activating a textbox will remove all other key-press bindings! They'll be stored in TextBox.old_callbacks and restored when TextBox.end_text_entry() is called. The default widget assumes only numerical data and will not allow text entry besides numerical characters and ('e','-','.') Parameters ---------- *ax* : :class:`matplotlib.axes.Axes` The parent axes for the widget *s* : str The initial text of the TextBox. *allowed_chars* : seq TextBox will only respond if event.key in allowed_chars. Defaults to None, which accepts anything. *type* : type Construct self.value using this type. self.value is only updated if self.type(<text>) succeeds. *enter_callback* : function A function of one argument that will be called with TextBox.value passed in as the only argument when enter is pressed *text_kwargs* : Additional keywork arguments are passed on to self.ax.text() Call :meth:`on_onchanged` to connect to TextBox updates """ AxesWidget.__init__(self, ax) self.ax.set_navigate(False) self.ax.set_yticks([]) self.ax.set_xticks([]) self.type = type self.allowed_chars = allowed_chars self.value = self.type(s) self.text = self.ax.text(0.025, 0.2, s, transform=self.ax.transAxes, **text_kwargs) self.enter_callback = enter_callback self._cid = None self._cursor = None self._cursorpos = len(self.text.get_text()) self.old_callbacks = {} self.cnt = 0 self.observers = {} self.connect_event('button_press_event', self._mouse_activate)
def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f', closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, **kwargs): """ Create a slider from *valmin* to *valmax* in axes *ax* *valinit* The slider initial position *label* The slider label *valfmt* Used to format the slider value *closedmin* and *closedmax* Indicate whether the slider interval is closed *slidermin* and *slidermax* Used to constrain the value of this slider to the values of other sliders. additional kwargs are passed on to ``self.poly`` which is the :class:`matplotlib.patches.Rectangle` which draws the slider knob. See the :class:`matplotlib.patches.Rectangle` documentation valid property names (e.g., *facecolor*, *edgecolor*, *alpha*, ...) """ AxesWidget.__init__(self, ax) self.valmin = valmin self.valmax = valmax self.val = valinit self.valinit = valinit self.poly = ax.axhspan(valmin, valinit, 0, 1, **kwargs) self.hline = ax.axhline(valinit, 0, 1, color='r', lw=1) self.valfmt = valfmt ax.set_yticks([]) ax.set_ylim((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) 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') self.cnt = 0 self.observers = {} self.closedmin = closedmin self.closedmax = closedmax self.slidermin = slidermin self.slidermax = slidermax self.drag_active = False