"Return an override dict. See :func:`~pyplot.text' docstring for info"

if fontdict is not None:

override.update(fontdict)

override.update(kwargs)

"""

if rotation in ('horizontal', None):

angle = 0.

elif rotation == 'vertical':

angle = 90.

else:

angle = float(rotation)

"""

projected_xs = []

projected_ys = []

theta = text.get_rotation()/180.*math.pi

tr = mtransforms.Affine2D().rotate(-theta)

for t, wh, x, y in text._get_layout(renderer)[1]:

w, h = wh

xt1, yt1 = tr.transform_point((x, y))

xt2, yt2 = xt1+w, yt1+h

projected_xs.extend([xt1, xt2])

projected_ys.extend([yt1, yt2])

xt_box, yt_box = min(projected_xs), min(projected_ys)

w_box, h_box = max(projected_xs) - xt_box, max(projected_ys) - yt_box

tr = mtransforms.Affine2D().rotate(theta)

x_box, y_box = tr.transform_point((xt_box, yt_box))

"""

zorder = 3

cached = maxdict(50)

def __str__(self):

return "Text(%g,%g,%s)"%(self._x,self._y,repr(self._text))

def __init__(self,

x=0, y=0, text='',

color=None, # defaults to rc params

verticalalignment='baseline',

horizontalalignment='left',

multialignment=None,

fontproperties=None, # defaults to FontProperties()

rotation=None,

linespacing=None,

rotation_mode=None,

path_effects=None,

**kwargs

):

"""

Artist.__init__(self)

self._x, self._y = x, y

if color is None: color = rcParams['text.color']

if fontproperties is None: fontproperties=FontProperties()

elif is_string_like(fontproperties): fontproperties=FontProperties(fontproperties)

self.set_path_effects(path_effects)

self.set_text(text)

self.set_color(color)

self._verticalalignment = verticalalignment

self._horizontalalignment = horizontalalignment

self._multialignment = multialignment

self._rotation = rotation

self._fontproperties = fontproperties

self._bbox = None

self._bbox_patch = None # a FancyBboxPatch instance

self._renderer = None

if linespacing is None:

linespacing = 1.2 # Maybe use rcParam later.

self._linespacing = linespacing

self.set_rotation_mode(rotation_mode)

self.update(kwargs)

#self.set_bbox(dict(pad=0))

def contains(self,mouseevent):

"""Test whether the mouse event occurred in the patch.

if callable(self._contains): return self._contains(self,mouseevent)

if not self.get_visible() or self._renderer is None:

return False,{}

l,b,w,h = self.get_window_extent().bounds

r, t = l+w, b+h

x, y = mouseevent.x, mouseevent.y

inside = (l <= x <= r and b <= y <= t)

cattr = {}

# if the text has a surrounding patch, also check containment for it,

# and merge the results with the results for the text.

if self._bbox_patch:

patch_inside, patch_cattr = self._bbox_patch.contains(mouseevent)

inside = inside or patch_inside

cattr["bbox_patch"] = patch_cattr

return inside, cattr

def _get_xy_display(self):

'get the (possibly unit converted) transformed x, y in display coords'

x, y = self.get_position()

return self.get_transform().transform_point((x,y))

def _get_multialignment(self):

if self._multialignment is not None: return self._multialignment

else: return self._horizontalalignment

def get_rotation(self):

'return the text angle as float in degrees'

return get_rotation(self._rotation) # string_or_number -> number

def set_rotation_mode(self, m):

"""

if m is None or m in ["anchor", "default"]:

self._rotation_mode = m

else:

raise ValueError("Unknown rotation_mode : %s" % repr(m))

def get_rotation_mode(self):

"get text rotation mode"

return self._rotation_mode

def update_from(self, other):

'Copy properties from other to self'

Artist.update_from(self, other)

self._color = other._color

self._multialignment = other._multialignment

self._verticalalignment = other._verticalalignment

self._horizontalalignment = other._horizontalalignment

self._fontproperties = other._fontproperties.copy()

self._rotation = other._rotation

self._picker = other._picker

self._linespacing = other._linespacing

def _get_layout(self, renderer):

"""

key = self.get_prop_tup()

if key in self.cached: return self.cached[key]

horizLayout = []

thisx, thisy = 0.0, 0.0

xmin, ymin = 0.0, 0.0

width, height = 0.0, 0.0

lines = self.get_text().split('\n')

whs = np.zeros((len(lines), 2))

horizLayout = np.zeros((len(lines), 4))

if self.get_path_effects():

from matplotlib.backends.backend_mixed import MixedModeRenderer

if isinstance(renderer, MixedModeRenderer):

def get_text_width_height_descent(*kl, **kwargs):

return RendererBase.get_text_width_height_descent(renderer._renderer,

*kl, **kwargs)

else:

def get_text_width_height_descent(*kl, **kwargs):

return RendererBase.get_text_width_height_descent(renderer,

*kl, **kwargs)

else:

get_text_width_height_descent = renderer.get_text_width_height_descent

# Find full vertical extent of font,

# including ascenders and descenders:

tmp, lp_h, lp_bl = get_text_width_height_descent('lp',

self._fontproperties,

ismath=False)

offsety = lp_h * self._linespacing

baseline = 0

for i, line in enumerate(lines):

clean_line, ismath = self.is_math_text(line)

if clean_line:

w, h, d = get_text_width_height_descent(clean_line,

self._fontproperties,

ismath=ismath)

else:

w, h, d = 0, 0, 0

whs[i] = w, h

# For general multiline text, we will have a fixed spacing

# between the "baseline" of the upper line and "top" of

# the lower line (instead of the "bottom" of the upper

# line and "top" of the lower line)

# For multiline text, increase the line spacing when the

# text net-height(excluding baseline) is larger than that

# of a "l" (e.g., use of superscripts), which seems

# what TeX does.

d_yoffset = max(0, (h-d)-(lp_h-lp_bl))

horizLayout[i] = thisx, thisy-(d + d_yoffset), \

w, h

baseline = (h - d) - thisy

thisy -= offsety + d_yoffset

width = max(width, w)

ymin = horizLayout[-1][1]

ymax = horizLayout[0][1] + horizLayout[0][3]

height = ymax-ymin

xmax = xmin + width

# get the rotation matrix

M = Affine2D().rotate_deg(self.get_rotation())

offsetLayout = np.zeros((len(lines), 2))

offsetLayout[:] = horizLayout[:, 0:2]

# now offset the individual text lines within the box

if len(lines)>1: # do the multiline aligment

malign = self._get_multialignment()

if malign == 'center':

offsetLayout[:, 0] += width/2.0 - horizLayout[:, 2] / 2.0

elif malign == 'right':

offsetLayout[:, 0] += width - horizLayout[:, 2]

# the corners of the unrotated bounding box

cornersHoriz = np.array(

[(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)],

np.float_)

# now rotate the bbox

cornersRotated = M.transform(cornersHoriz)

txs = cornersRotated[:, 0]

tys = cornersRotated[:, 1]

# compute the bounds of the rotated box

xmin, xmax = txs.min(), txs.max()

ymin, ymax = tys.min(), tys.max()

width = xmax - xmin

height = ymax - ymin

# Now move the box to the target position offset the display

# bbox by alignment

halign = self._horizontalalignment

valign = self._verticalalignment

rotation_mode = self.get_rotation_mode()

if rotation_mode != "anchor":

# compute the text location in display coords and the offsets

# necessary to align the bbox with that location

if halign=='center': offsetx = (xmin + width/2.0)

elif halign=='right': offsetx = (xmin + width)

else: offsetx = xmin

if valign=='center': offsety = (ymin + height/2.0)

elif valign=='top': offsety = (ymin + height)

elif valign=='baseline': offsety = (ymin + height) - baseline

else: offsety = ymin

else:

xmin1, ymin1 = cornersHoriz[0]

xmax1, ymax1 = cornersHoriz[2]

if halign=='center': offsetx = (xmin1 + xmax1)/2.0

elif halign=='right': offsetx = xmax1

else: offsetx = xmin1

if valign=='center': offsety = (ymin1 + ymax1)/2.0

elif valign=='top': offsety = ymax1

elif valign=='baseline': offsety = ymax1 - baseline

else: offsety = ymin1

offsetx, offsety = M.transform_point((offsetx, offsety))

xmin -= offsetx

ymin -= offsety

bbox = Bbox.from_bounds(xmin, ymin, width, height)

# now rotate the positions around the first x,y position

xys = M.transform(offsetLayout)

xys -= (offsetx, offsety)

xs, ys = xys[:, 0], xys[:, 1]

ret = bbox, zip(lines, whs, xs, ys)

self.cached[key] = ret

return ret

def set_path_effects(self, path_effects):

self._path_effects = path_effects

def get_path_effects(self):

return self._path_effects

def set_bbox(self, rectprops):

"""

# The self._bbox_patch object is created only if rectprops has

# boxstyle key. Otherwise, self._bbox will be set to the

# rectprops and the bbox will be drawn using bbox_artist

# function. This is to keep the backward compatibility.

if rectprops is not None and "boxstyle" in rectprops:

props = rectprops.copy()

boxstyle = props.pop("boxstyle")

bbox_transmuter = props.pop("bbox_transmuter", None)

self._bbox_patch = FancyBboxPatch((0., 0.),

1., 1.,

boxstyle=boxstyle,

bbox_transmuter=bbox_transmuter,

transform=mtransforms.IdentityTransform(),

**props)

self._bbox = None

else:

self._bbox_patch = None

self._bbox = rectprops

def get_bbox_patch(self):

"""

return self._bbox_patch

def update_bbox_position_size(self, renderer):

"""

if self._bbox_patch:

trans = self.get_transform()

# don't use self.get_position here, which refers to text position

# in Text, and dash position in TextWithDash:

posx = float(self.convert_xunits(self._x))

posy = float(self.convert_yunits(self._y))

posx, posy = trans.transform_point((posx, posy))

x_box, y_box, w_box, h_box = _get_textbox(self, renderer)

self._bbox_patch.set_bounds(0., 0.,

w_box, h_box)

theta = self.get_rotation()/180.*math.pi

tr = mtransforms.Affine2D().rotate(theta)

tr = tr.translate(posx+x_box, posy+y_box)

self._bbox_patch.set_transform(tr)

fontsize_in_pixel = renderer.points_to_pixels(self.get_size())

self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

#self._bbox_patch.draw(renderer)

def _draw_bbox(self, renderer, posx, posy):

""" Update the location and the size of the bbox

x_box, y_box, w_box, h_box = _get_textbox(self, renderer)

self._bbox_patch.set_bounds(0., 0.,

w_box, h_box)

theta = self.get_rotation()/180.*math.pi

tr = mtransforms.Affine2D().rotate(theta)

tr = tr.translate(posx+x_box, posy+y_box)

self._bbox_patch.set_transform(tr)

fontsize_in_pixel = renderer.points_to_pixels(self.get_size())

self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

self._bbox_patch.draw(renderer)

@allow_rasterization

def draw(self, renderer):

"""

if renderer is not None:

self._renderer = renderer

if not self.get_visible(): return

if self.get_text().strip() == '': return

renderer.open_group('text', self.get_gid())

bbox, info = self._get_layout(renderer)

trans = self.get_transform()

# don't use self.get_position here, which refers to text position

# in Text, and dash position in TextWithDash:

posx = float(self.convert_xunits(self._x))

posy = float(self.convert_yunits(self._y))

posx, posy = trans.transform_point((posx, posy))

canvasw, canvash = renderer.get_canvas_width_height()

# draw the FancyBboxPatch

if self._bbox_patch:

self._draw_bbox(renderer, posx, posy)

gc = renderer.new_gc()

gc.set_foreground(self.get_color())

gc.set_alpha(self.get_alpha())

gc.set_url(self._url)

self._set_gc_clip(gc)

if self._bbox:

bbox_artist(self, renderer, self._bbox)

angle = self.get_rotation()

if rcParams['text.usetex']:

for line, wh, x, y in info:

if not np.isfinite(x) or not np.isfinite(y):

continue

x = x + posx

y = y + posy

if renderer.flipy():

y = canvash-y

clean_line, ismath = self.is_math_text(line)

if self.get_path_effects():

for path_effect in self.get_path_effects():

path_effect.draw_tex(renderer, gc, x, y, clean_line,

self._fontproperties, angle)

else:

renderer.draw_tex(gc, x, y, clean_line,

self._fontproperties, angle)

else:

for line, wh, x, y in info:

if not np.isfinite(x) or not np.isfinite(y):

continue

x = x + posx

y = y + posy

if renderer.flipy():

y = canvash-y

clean_line, ismath = self.is_math_text(line)

if self.get_path_effects():

for path_effect in self.get_path_effects():

path_effect.draw_text(renderer, gc, x, y, clean_line,

self._fontproperties, angle,

ismath=ismath)

else:

renderer.draw_text(gc, x, y, clean_line,

self._fontproperties, angle,

ismath=ismath)

gc.restore()

renderer.close_group('text')

def get_color(self):

"Return the color of the text"

return self._color

def get_fontproperties(self):

"Return the :class:`~font_manager.FontProperties` object"

return self._fontproperties

def get_font_properties(self):

'alias for get_fontproperties'

return self.get_fontproperties()

def get_family(self):

"Return the list of font families used for font lookup"

return self._fontproperties.get_family()

def get_fontfamily(self):

'alias for get_family'

return self.get_family()

def get_name(self):

"Return the font name as string"

return self._fontproperties.get_name()

def get_style(self):

"Return the font style as string"

return self._fontproperties.get_style()

def get_size(self):

"Return the font size as integer"

return self._fontproperties.get_size_in_points()

def get_variant(self):

"Return the font variant as a string"

return self._fontproperties.get_variant()

def get_fontvariant(self):

'alias for get_variant'

return self.get_variant()

def get_weight(self):

"Get the font weight as string or number"

return self._fontproperties.get_weight()

def get_fontname(self):

'alias for get_name'

return self.get_name()

def get_fontstyle(self):

'alias for get_style'

return self.get_style()

def get_fontsize(self):

'alias for get_size'

return self.get_size()

def get_fontweight(self):

'alias for get_weight'

return self.get_weight()

def get_stretch(self):

'Get the font stretch as a string or number'

return self._fontproperties.get_stretch()

def get_fontstretch(self):

'alias for get_stretch'

return self.get_stretch()

def get_ha(self):

'alias for get_horizontalalignment'

return self.get_horizontalalignment()

def get_horizontalalignment(self):

"""

return self._horizontalalignment

def get_position(self):

"Return the position of the text as a tuple (*x*, *y*)"

x = float(self.convert_xunits(self._x))

y = float(self.convert_yunits(self._y))

return x, y

def get_prop_tup(self):

"""

x, y = self.get_position()

return (x, y, self.get_text(), self._color,

self._verticalalignment, self._horizontalalignment,

hash(self._fontproperties),

self._rotation, self._rotation_mode,

self.figure.dpi, id(self._renderer),

)

def get_text(self):

"Get the text as string"

return self._text

def get_va(self):

'alias for :meth:`getverticalalignment`'

return self.get_verticalalignment()

def get_verticalalignment(self):

"""

return self._verticalalignment

def get_window_extent(self, renderer=None, dpi=None):

'''

#return _unit_box

if not self.get_visible(): return Bbox.unit()

if dpi is not None:

dpi_orig = self.figure.dpi

self.figure.dpi = dpi

if self.get_text().strip() == '':

tx, ty = self._get_xy_display()

return Bbox.from_bounds(tx,ty,0,0)

if renderer is not None:

self._renderer = renderer

if self._renderer is None:

raise RuntimeError('Cannot get window extent w/o renderer')

bbox, info = self._get_layout(self._renderer)

x, y = self.get_position()

x, y = self.get_transform().transform_point((x, y))

bbox = bbox.translated(x, y)

if dpi is not None:

self.figure.dpi = dpi_orig

return bbox

def set_backgroundcolor(self, color):

"""

if self._bbox is None:

self._bbox = dict(facecolor=color, edgecolor=color)

else:

self._bbox.update(dict(facecolor=color))

def set_color(self, color):

"""

# Make sure it is hashable, or get_prop_tup will fail.

try:

hash(color)

except TypeError:

color = tuple(color)

self._color = color

def set_ha(self, align):

'alias for set_horizontalalignment'

self.set_horizontalalignment(align)

def set_horizontalalignment(self, align):

"""

legal = ('center', 'right', 'left')

if align not in legal:

raise ValueError('Horizontal alignment must be one of %s' % str(legal))

self._horizontalalignment = align

def set_ma(self, align):

'alias for set_verticalalignment'

self.set_multialignment(align)

def set_multialignment(self, align):

"""

legal = ('center', 'right', 'left')

if align not in legal:

raise ValueError('Horizontal alignment must be one of %s' % str(legal))

self._multialignment = align

def set_linespacing(self, spacing):

"""

self._linespacing = spacing

def set_family(self, fontname):

"""

self._fontproperties.set_family(fontname)

def set_variant(self, variant):

"""

self._fontproperties.set_variant(variant)

def set_fontvariant(self, variant):

'alias for set_variant'

return self.set_variant(variant)

def set_name(self, fontname):

"""alias for set_family"""

return self.set_family(fontname)

def set_fontname(self, fontname):

"""alias for set_family"""

self.set_family(fontname)

def set_style(self, fontstyle):

"""

self._fontproperties.set_style(fontstyle)

def set_fontstyle(self, fontstyle):

'alias for set_style'

return self.set_style(fontstyle)

def set_size(self, fontsize):

"""

self._fontproperties.set_size(fontsize)

def set_fontsize(self, fontsize):

'alias for set_size'

return self.set_size(fontsize)

def set_weight(self, weight):

"""

self._fontproperties.set_weight(weight)

def set_fontweight(self, weight):

'alias for set_weight'

return self.set_weight(weight)

def set_stretch(self, stretch):

"""

self._fontproperties.set_stretch(stretch)

def set_fontstretch(self, stretch):

'alias for set_stretch'

return self.set_stretch(stretch)

def set_position(self, xy):

"""

self.set_x(xy[0])

self.set_y(xy[1])

def set_x(self, x):

"""

self._x = x

def set_y(self, y):

"""

self._y = y

def set_rotation(self, s):

"""

self._rotation = s

def set_va(self, align):

'alias for set_verticalalignment'

self.set_verticalalignment(align)

def set_verticalalignment(self, align):

"""

legal = ('top', 'bottom', 'center', 'baseline')

if align not in legal:

raise ValueError('Vertical alignment must be one of %s' % str(legal))

self._verticalalignment = align

def set_text(self, s):

"""

self._text = '%s' % (s,)

@staticmethod

def is_math_text(s):

"""

# Did we find an even number of non-escaped dollar signs?

# If so, treat is as math text.

if rcParams['text.usetex']:

if s == ' ':

s = r'\ '

return s, 'TeX'

if cbook.is_math_text(s):

return s, True

else:

return s.replace(r'\$', '$'), False

def set_fontproperties(self, fp):

"""