def __init__(self, x, y, text, offset=(0, 0), **kwargs): """Initialize an instance of `TextCollection`. This class encompasses drawing a collection of text values at a variety of locations. Parameters ---------- x : array_like The x locations, in data coordinates, for the text y : array_like The y locations, in data coordinates, for the text text : array_like of str The string values to draw offset : (int, int) The offset x and y, in normalized coordinates, to draw the text relative to the data locations. kwargs : arbitrary keywords arguments """ Text.__init__(self, **kwargs) self.x = x self.y = y self.text = text self.offset = offset if not hasattr(self, '_usetex'): # Only needed for matplotlib 1.4 compatibility self._usetex = None
def __init__(self, x, y, text, offset=(0, 0), **kwargs): Text.__init__(self, **kwargs) self.x = x self.y = y self.text = text self.offset = offset if not hasattr(self, '_usetex'): # Only needed for matplotlib 1.4 compatibility self._usetex = None
def __init__(self, axes, on_dblclick, *args, **kwargs): Text.__init__(self, *args, **kwargs) self.axes = axes self.axes.add_artist(self) self.connections = [ axes.figure.canvas.mpl_connect('button_press_event', self.onclick), axes.figure.canvas.mpl_connect('button_release_event', self.onrelease), axes.figure.canvas.mpl_connect('motion_notify_event', self.onmove), ] self.press = None self.on_dblclick = on_dblclick
def _generate_node_labels(pos, styles, *, ax): key_map = { 'font_size': 'size', 'font_color': 'color', 'font_family': 'family', 'font_weight': 'weight', 'alpha': 'alpha', 'bbox': 'bbox', 'horizontalalignment': 'horizontalalignment', 'verticalalignment': 'verticalalignment' } node_labels_dict = {} for node, nstyle in styles.items(): properties = {key_map[k]: v for k, v in nstyle.items() if k in key_map} x, y = pos[node] if 'label' in nstyle: label = nstyle['label'] else: label = str(node) # this makes "1" and 1 the same node_labels_dict[node] = Text(x, y, label, transform=ax.transData, clip_on=True, **properties) return node_labels_dict
def on_xlims_change(ax): display_xs = list() fontheight = 24 for p in ax.get_xticks(): xdisplay, ydisplay = ax.transData.transform_point((p, 0)) display_xs.append(xdisplay) dxa = np.array(display_xs) dxd = dxa[1:] - dxa[:-1] min_dx = dxd.min() + 12 tes = list() for l in ax.get_xticklabels(): text = Text(text=l, figure=ax.figure) extent = text.get_window_extent() tes.append(extent.width) fontheight = extent.height max_tx = np.array(tes).max() if min_dx > max_tx: angle = 0 elif min_dx < fontheight * 2: angle = 90 else: angle = math.atan(fontheight / (min_dx - fontheight * 2)) / math.pi * 180 angle = max(0, min(90, angle)) plt.xticks(rotation=angle, horizontalalignment="right") plt.tight_layout()
def test_text_with_arrow_annotation_get_window_extent(): headwidth = 21 fig, ax = plt.subplots(dpi=100) txt = ax.text(s='test', x=0, y=0) ann = ax.annotate( 'test', xy=(0.0, 50.0), xytext=(50.0, 50.0), xycoords='figure pixels', arrowprops={ 'facecolor': 'black', 'width': 2, 'headwidth': headwidth, 'shrink': 0.0}) plt.draw() renderer = fig.canvas.renderer # bounding box of text text_bbox = txt.get_window_extent(renderer=renderer) # bounding box of annotation (text + arrow) bbox = ann.get_window_extent(renderer=renderer) # bounding box of arrow arrow_bbox = ann.arrow.get_window_extent(renderer) # bounding box of annotation text ann_txt_bbox = Text.get_window_extent(ann) # make sure annotation with in 50 px wider than # just the text eq_(bbox.width, text_bbox.width + 50.0) # make sure the annotation text bounding box is same size # as the bounding box of the same string as a Text object eq_(ann_txt_bbox.height, text_bbox.height) eq_(ann_txt_bbox.width, text_bbox.width) # compute the expected bounding box of arrow + text expected_bbox = Bbox.union([ann_txt_bbox, arrow_bbox]) assert_almost_equal(bbox.height, expected_bbox.height)
def __init__( self, x=0, y=0, text='', color=None, # defaults to rc params verticalalignment='bottom', horizontalalignment='left', multialignment=None, fontproperties=None, # defaults to FontProperties() rotation=None, linespacing=None, **kwargs): Artist.__init__(self) if color is None: colors = rcParams['text.color'] if fontproperties is None: fontproperties = FontProperties() elif is_string_like(fontproperties): fontproperties = FontProperties(fontproperties) self._animated = False # if is_string_like(text): # text = [text] self._textobjs = [ Text(x[ind], y[ind], text[ind], color, verticalalignment, horizontalalignment, multialignment, fontproperties, rotation, linespacing, **kwargs) for ind in xrange(len(x)) ] self.update(kwargs)
def _create_ticks(self, step=0.2, tick_length=0.025, **kwargs): x = np.arange(step, 1., step) n = x.shape[0] tick_start, tick_end = np.zeros((n, 3)), np.zeros((n, 3)) tick_start[:, 0] = x tick_start[:, 2] = 1. - x tick_end[:, 0] = x tick_end[:, 2] = 1. - x + tick_length tick_end[:, 1] = -tick_length tick_labels = [] ha = ["center", "left", "right"] va = ["top", "bottom", "center"] rot = [-60, 60, 0] segs = np.zeros((n * 3, 2, 2)) for i, perm in enumerate([(0, 2, 1), (1, 0, 2), (2, 1, 0)]): start = self._simplex_transform.transform(tick_start[:, perm]) end = self._simplex_transform.transform(tick_end[:, perm]) segs[i * n:(i + 1) * n, 0, :], segs[i * n:(i + 1) * n, 1, :] = start, end for j, x_ in enumerate(x): tick_labels.append( Text( end[j, 0], end[j, 1], "{0:.1f}".format(x_), horizontalalignment=ha[i], verticalalignment=va[i], rotation=rot[i], color=kwargs["color"], fontsize=rcParams["xtick.labelsize"])) line_segments = LineCollection(segs, **kwargs) return line_segments, tick_labels
def test_text_annotation_get_window_extent(): figure = Figure(dpi=100) renderer = RendererAgg(200, 200, 100) # Only text annotation annotation = Annotation('test', xy=(0, 0)) annotation.set_figure(figure) text = Text(text='test', x=0, y=0) text.set_figure(figure) bbox = annotation.get_window_extent(renderer=renderer) text_bbox = text.get_window_extent(renderer=renderer) eq_(bbox.width, text_bbox.width) eq_(bbox.height, text_bbox.height) _, _, d = renderer.get_text_width_height_descent( 'text', annotation._fontproperties, ismath=False) _, _, lp_d = renderer.get_text_width_height_descent( 'lp', annotation._fontproperties, ismath=False) below_line = max(d, lp_d) # These numbers are specific to the current implementation of Text points = bbox.get_points() eq_(points[0, 0], 0.0) eq_(points[1, 0], text_bbox.width) eq_(points[0, 1], -below_line) eq_(points[1, 1], text_bbox.height - below_line)
def test_update_mutate_input(): inp = dict(fontproperties=FontProperties(weight="bold"), bbox=None) cache = dict(inp) t = Text() t.update(inp) assert inp['fontproperties'] == cache['fontproperties'] assert inp['bbox'] == cache['bbox']
def test_bar_plot(self): # GH38947 # Test bar plot with string and int index from matplotlib.text import Text expected = [Text(0, 0, "0"), Text(1, 0, "Total")] df = DataFrame( { "a": [1, 2], }, index=Index([0, "Total"]), ) plot_bar = df.plot.bar() assert all((a.get_text() == b.get_text()) for a, b in zip(plot_bar.get_xticklabels(), expected))
def draw_legend(data, da, lyr): """ Draw letter 'a' in the box Parameters ---------- data : dataframe da : DrawingArea lyr : layer Returns ------- out : DrawingArea """ key = Text(x=0.5 * da.width, y=0.5 * da.height, text='a', alpha=data['alpha'], size=data['size'], family=lyr.geom.params['family'], color=data['color'], rotation=data['angle'], horizontalalignment='center', verticalalignment='center') da.add_artist(key) return da
def __setup_overflow(self): bbox = self.axes.bbox box = dict(boxstyle='round', fc='white', ec='black', alpha=0.5, clip_box=bbox) self.overflowLabels['left'] = Text(0, 0.9, '', fontsize='xx-small', ha="left", va="top", bbox=box, transform=self.axes.transAxes, alpha=0.5) self.overflowLabels['right'] = Text(1, 0.9, '', fontsize='xx-small', ha="right", va="top", bbox=box, transform=self.axes.transAxes, alpha=0.5) self.overflowLabels['top'] = Text(0.9, 1, '', fontsize='xx-small', ha="right", va="top", bbox=box, transform=self.axes.transAxes, alpha=0.5) self.overflowLabels['bottom'] = Text(0.9, 0, '', fontsize='xx-small', ha="right", va="bottom", bbox=box, transform=self.axes.transAxes, alpha=0.5) for label in self.overflowLabels.itervalues(): self.axes.add_artist(label)
def test_barh_plot_labels_mixed_integer_string(self): # GH39126 # Test barh plot with string and integer at the same column from matplotlib.text import Text df = DataFrame([{ "word": 1, "value": 0 }, { "word": "knowledg", "value": 2 }]) plot_barh = df.plot.barh(x="word", legend=None) expected_yticklabels = [Text(0, 0, "1"), Text(0, 1, "knowledg")] assert all(actual.get_text() == expected.get_text() for actual, expected in zip(plot_barh.get_yticklabels(), expected_yticklabels))
def ani_init(self, axes): self.ax = axes self.centre_x = 0.5 * (self.input_x + self.output_x) min_x = min(self.input_x, self.output_x) max_x = max(self.input_x, self.output_x) if (max_x - min_x) < (2 * self.min_hw): min_x = self.centre_x - self.min_hw max_x = self.centre_x + self.min_hw self.centre_y = 0.5 * (self.input_y + self.output_y) min_y = min(self.input_y, self.output_y) max_y = max(self.input_y, self.output_y) if (max_y - min_y) < (2 * self.min_hh): min_y = self.centre_y - self.min_hh max_y = self.centre_y + self.min_hh self.upper_y = 0.25 * self.centre_y + 0.75 * max_y coords = np.array( [[min_x, max_x, max_x, min_x], [min_y, min_y, max_y, max_y]], dtype=np.float) coords = coords.transpose() poly = Polygon(xy=coords, closed=True, **self.outline_poly_kwargs) self.ax.add_patch(poly) self.box_poly = poly if self.onebit_mode: # Make a circle to show the 'blob'. circ = Circle(xy=(self.centre_x, self.centre_y), axes=self.ax, **self.onebit_circle_kwargs) self.ax.add_patch(circ) self.els['blob_circle'] = circ else: # Make a text to show the value. kwargs = {'fontsize': 30} kwargs.update(self.value_text_kwargs) txt = Text(x=self.centre_x, y=self.centre_y, text=self.value_text_unset, verticalalignment='center', horizontalalignment='center', **self.value_text_kwargs) self.ax.add_artist(txt) self.value_text = txt # Setup self._anidata to contain all animation state information. AniData = SlotsHolder.newtype('pulselatch_anidata', ('value_text', 'blob_circle')) ValueTextData = SlotsHolder.newtype( 'ValueTextData', ('position', 'text', 'color', 'fontstyle', 'fontweight')) self._anidata = AniData() self._anidata.value_text = self._get_element_state( self.value_text, ValueTextData) # Also require a dummy 'bloc_circle' object (for now, just testing) self.blob_circle = None self._anidata.blob_circle = SlotsHolder.newtype( 'DummyBlobCircleData', [])
def _make_plot(self, ax, plt_data, max_val, curPicks, starttime, cur_starttime, sr, transOffset, caption=None): npts = len(plt_data) t = np.array([(starttime + tmp).datetime for tmp in np.arange(0, npts) / sr]) ax.plot(t, plt_data / max_val) plt.ylim([-1, 1]) if caption: ax.text(.95, .9, caption, transform=ax.transAxes, va='top', ha='right', fontsize=10, backgroundcolor='white') for curStage, pickStage in enumerate(curPicks): for pick in pickStage: pick_sample = pick.time.datetime col = 'red' if pick['phase_hint'] == 'P' else 'black' # col = 'red' ax.axvline(pick_sample, c=col) snr = None for c in pick.comments: if 'SNR=' not in c.text: continue snr = c.text.split('=')[1] displayText = '%s%s' % (pick.phase_hint, curStage) if snr: displayText = '%s - %s' % (displayText, snr) label = Text(pick_sample, ax.get_ylim()[1] * .7, displayText, color=col, backgroundcolor='white', size=10, alpha=.8, transform=transOffset) ax.add_artist(label) if hasattr(pick, 'tt_residual'): pick_sample = (pick.time - pick.tt_residual).datetime ax.axvline(pick_sample, c='green')
def draw_region_labels(regions, ax=None, fontsize=7, **kw): if ax is None: ax = plt.gca() ax.artists = [] for region in regions: cent = region.centroid t = Text(cent[1], cent[0], str(region.label), fontsize=fontsize, **kw) t.set_clip_on(True) ax.add_artist(t)
def create_artists(self, legend, text, xdescent, ydescent, width, height, fontsize, trans): tx = Text(width / 2., height / 2, text, fontsize=fontsize, ha="center", va="center") return [tx]
def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans): tx = Text(width / 2, height / 2, orig_handle.get_text(), fontsize=fontsize, ha="center", va="center", fontweight="normal") return [tx]
def is_math_text(text, usetex=False): """ Comprueba si un texto es aceptado por la figura o no. :param text: String. Texto matemático (Sin usar $) :param usetex: Bool. Usar o no el compilador de Latex. :return: Bool """ _, is_acceptable = Text.is_math_text(str(text), bool(usetex)) return is_acceptable
def _generate_edge_labels(pos, styles, *, ax): key_map = { 'font_size': 'size', 'font_color': 'color', 'font_family': 'family', 'font_weight': 'weight', 'alpha': 'alpha', 'bbox': 'bbox', 'horizontalalignment': 'horizontalalignment', 'verticalalignment': 'verticalalignment' } edge_labels_dict = {} for edge, estyle in styles.items(): properties = {key_map[k]: v for k, v in estyle.items() if k in key_map} if 'label' in estyle: label = estyle['label'] else: label = str(edge) # this makes "1" and 1 the same if 'label_pos' in estyle: label_pos = estyle['label_pos'] else: label_pos = 0.5 (x1, y1) = pos[edge[0]] (x2, y2) = pos[edge[1]] (x, y) = (x1 * label_pos + x2 * (1.0 - label_pos), y1 * label_pos + y2 * (1.0 - label_pos)) if 'rotate' in estyle and estyle['rotate'] is True: # in degrees angle = np.arctan2(y2 - y1, x2 - x1) / (2.0 * np.pi) * 360 # make label orientation "right-side-up" if angle > 90: angle -= 180 if angle < -90: angle += 180 # transform data coordinate angle to screen coordinate angle xy = np.array((x, y)) trans_angle = ax.transData.transform_angles( np.array((angle, )), xy.reshape((1, 2)))[0] else: trans_angle = 0.0 edge_labels_dict[edge] = Text(x, y, label, rotation=trans_angle, transform=ax.transData, clip_on=True, zorder=1, **properties) return edge_labels_dict
def create_artists(self, legend, tup, xdescent, ydescent, width, height, fontsize, trans): tx = Text(width / 2., height / 2, tup[0], fontsize=fontsize, ha="center", va="center", color=tup[1], fontweight="bold") return [tx]
def string(self, x, y, string, ha=None, va=None, rotation=None, color=None): opts = self.text_opts.copy() if ha is not None: opts['ha'] = ha if va is not None: opts['va'] = va if rotation is not None: opts['rotation'] = rotation if color is not None: opts['color'] = color return Text(x, y, string, **opts)
def axes(self, ax): self._axes = ax from matplotlib.text import Text self._text = Text(self.x, self.y, f"${self.string}$", horizontalalignment='center', verticalalignment='center', size=FONT, usetex=True) ax.add_artist(self._text)
def __init__(self, location='C', alpha=0.75, color='red', textprop={'fontsize':20, 'fontweight':'bold'}, *args, **kwargs): self.figure = None self._text_alpha = alpha self._text = Text(visible=False,color=color,alpha=alpha,zorder=100,**textprop) self.set_location( location ) self._timer = None self._fadeout_timer = None self._fadeout_alpha = 0 super(AxesMessage, self).__init__(*args, **kwargs)
def __setup_measure(self): dashesHalf = [1, 5, 5, 5, 5, 5] self.lines[Markers.HFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lines[Markers.HFE] = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lines[Markers.OFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') self.lines[Markers.OFE] = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') if matplotlib.__version__ >= '1.3': effect = patheffects.withStroke(linewidth=3, foreground="w", alpha=0.75) self.lines[Markers.HFS].set_path_effects([effect]) self.lines[Markers.HFE].set_path_effects([effect]) self.lines[Markers.OFS].set_path_effects([effect]) self.lines[Markers.OFE].set_path_effects([effect]) for line in self.lines.itervalues(): self.axes.add_line(line) bbox = self.axes.bbox box = dict(boxstyle='round', fc='white', ec='purple', clip_box=bbox) self.labels[Markers.HFS] = Text(0, 0, '-3dB', fontsize='xx-small', ha="center", va="top", bbox=box, color='purple') self.labels[Markers.HFE] = Text(0, 0, '-3dB', fontsize='xx-small', ha="center", va="top", bbox=box, color='purple') box['ec'] = '#996600' self.labels[Markers.OFS] = Text(0, 0, 'OBW', fontsize='xx-small', ha="center", va="top", bbox=box, color='#996600') self.labels[Markers.OFE] = Text(0, 0, 'OBW', fontsize='xx-small', ha="center", va="top", bbox=box, color='#996600') for label in self.labels.itervalues(): self.axes.add_artist(label)
def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans): p = Text(x=-xdescent, y=-ydescent, text=orig_handle.get_text()) self.update_prop(p, orig_handle, legend) p.set_transform(trans) p.set_fontsize(0.75 * fontsize) c = Rectangle(xy=(-xdescent, -ydescent - (height / 5)), width=width, height=7 * height / 5, facecolor="none", edgecolor="none") c.set_transform(trans) p.set_clip_path(c) return [p]
def shape(self, height, yrange, rotated): rot = 0 if rotated: rot += 90 #if span.Reverse: rot+= 180 g = rlg2mpl.Group() kw = dict(ha='center', va='baseline', rotation=rot, font_properties=self.font_properties) for (motif, cvalues, offsets) in self.per_shape_values: letter = self.alphabet[motif] c = len(cvalues) for (i, (x,y)) in enumerate(offsets): s = Text(x, y, letter, color=cvalues[i%c], **kw) g.add(s) return g
def __call__(self, height, label, map, value, yrange, rotated): #return self.FeatureClass(label, map) g = rlg2mpl.Group() last = first = None if self.range_required and not yrange: warnings.warn("'%s' graph values are all zero" % label) yrange = 1.0 if map.useful and self.one_span: map = map.getCoveringSpan() for (i, span) in enumerate(map.spans): #if last is not None: # g.add(rlg2mpl.Line(last, height, part.Start, height)) if span.lost or (value is None and self.range_required): continue if span.Reverse: (start, end) = (span.End, span.Start) (tidy_start, tidy_end) = (span.tidy_end, span.tidy_start) else: (start, end) = (span.Start, span.End) (tidy_start, tidy_end) = (span.tidy_start, span.tidy_end) shape = self._item_shape(start, end, tidy_start, tidy_end, height, value, yrange, rotated, last=i == len(map.spans) - 1) g.add(shape) last = end if first is None: first = start if self.showLabel and label and last is not None and height > 7: font_height = 12 #self.label_font.get_size_in_points() text_width = llen(label, font_height) if (text_width < abs(first - last)): label_shape = Text( (first + last) / 2, height / 2, label, ha="center", va="center", rotation=[0, 90][rotated], #font_properties=self.label_font, ) g.add(label_shape) else: pass #warnings.warn("couldn't fit feature label '%s'" % label) return g
def plot_marker_text(project, marker, offset, marker_scale, base_y, axes): """ Plots a markers text using the given offset and scale """ text = getattr(marker, "__plot_text", None) within_range = bool(project.axes_xlimit == 0 or (marker.position >= project.axes_xmin and marker.position <= project.axes_xmax)) if marker.visible and marker.style != "offset" and within_range: # prevent empty $$ from causing an error: save_label = marker.label.replace("$$", "") # Calculate position and set transform: x = float(marker.position) + float(marker.x_offset) if marker.top == 0: # relative to base y = base_y + (marker.top_offset + marker.y_offset) * marker_scale transform = axes.transData elif marker.top == 1: # top of plot y = settings.PLOT_TOP + float(marker.y_offset) transform = transforms.blended_transform_factory( axes.transData, axes.get_figure().transFigure) kws = dict(text=save_label, x=x, y=y, clip_on=False, transform=transform, horizontalalignment=marker.align, verticalalignment="center", rotation=(90 - marker.angle), rotation_mode="anchor", color=marker.color, weight="heavy") if text: for key in kws: getattr(text, "set_%s" % key)(kws[key]) else: text = Text(**kws) if not text in axes.get_children(): axes.add_artist(text) elif text: try: text.remove() except: pass marker.__plot_text = text return text
def __init__(self, depends=(), essential_data=None, create_type=1, infinite=False): self.text = Text(0, 0, '') super(KingGeometry, self).__init__([], []) super(KingCurve, self).__init__(depends=depends, essential_data=essential_data, create_type=create_type, infinite=infinite) self.text.set_text(self.get_label()) self.mouse_select_priority = 2 if create_type == 1: self.mouse_translation = True
def test_update_legend(self): line1 = Line2D([], [], label='line1') line2 = Line2D([], [], label='line2') line3 = Line2D([], [], label='line_not_to_show1') line4 = Line2D([], [], label='') line3.set_linestyle('None') line1_text = Text('line1') line2_text = Text('line2') get_legend_mock = MagicMock() get_legend_mock.get_lines = MagicMock(return_value=[line1, line2]) get_legend_mock.get_texts = MagicMock( return_value=[line1_text, line2_text]) self.axes.get_children = MagicMock( return_value=[line1, line2, line3, line4, "nonsense", 4]) self.axes.legend = MagicMock(return_value=get_legend_mock) self.slice_plot.update_legend() self.axes.legend.assert_called_with([line1, line2], ['line1', 'line2'], fontsize=ANY) self.assertEqual(self.slice_plot._legend_dict[line1], line1) self.assertEqual(self.slice_plot._legend_dict[line2], line2) self.assertEqual(self.slice_plot._legend_dict[line1_text], line1) self.assertEqual(self.slice_plot._legend_dict[line2_text], line2)
def make_letters(coords,letters,color='black'): """Returns list of Text objects, given list of coordinates and letteres. - coords: list of [x,y] coordinates, already scaled to matplotlib axes. - letters: list of letters to be drawn at given coordinates. Must be same size list as coords. - color: color of the letters. """ letter_list = [] for coord, letter in zip(coords, letters): x_coord, y_coord = coord curr_letter = Text(x_coord, y_coord, letter) letter_list.append(curr_letter) return letter_list
def make_new_artist(self): """ Compute new form of the element to be drawn, using information from self's fields. Usually, this will mean creating a new artist and applying a transformation to it, based on the chosen effect. Sometimes, the element to be drawn will consist of a *list* of artists. :return: new artist --- or list of artists --- to be drawn. """ retval = [] if self.is_right_angle(self.theta1, self.theta2): # Right angle: draw square of side radius/2, rotated according to the segments' position vertices = np.array([ self.center, (self.center[0] + self.radius / 2, self.center[1]), (self.center[0] + self.radius / 2, self.center[1] + self.radius / 2), (self.center[0], self.center[1] + self.radius / 2), ]) retval.append( Polygon(vertices, closed=True, fill=True, transform=Affine2D().rotate_deg_around( *self.center, self.theta1) + self.ax.transData, **self.artist_kwargs)) else: # Not right angle: draw wedge retval.append( Wedge(self.center, self.radius, self.theta1, self.theta2, **self.artist_kwargs)) if self.label is not None: retval.append( Text( x=self.x_label, y=self.y_label, text=self.label, color=self.labelcolor, usetex=True, fontsize=30 # TODO )) return retval
def remove(self): for connection in self.connections: self.axes.figure.canvas.mpl_disconnect(connection) Text.remove(self)