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

if fontdict is not None:

override.update(fontdict)

override.update(kwargs)

"""Temporarily inserts newlines to the text if the wrap option is enabled.

if textobj.get_wrap():

old_text = textobj.get_text()

try:

textobj.set_text(textobj._get_wrapped_text())

yield textobj

finally:

textobj.set_text(old_text)

else:

"""

try:

angle = float(rotation)

except (ValueError, TypeError):

if cbook._str_equal(rotation, 'horizontal') or rotation is None:

angle = 0.

elif cbook._str_equal(rotation, 'vertical'):

angle = 90.

else:

raise ValueError("rotation is {0} expected either 'horizontal'"

" 'vertical', numeric value or"

"None".format(rotation))

"""

# TODO : This function may move into the Text class as a method. As a

# matter of fact, The information from the _get_textbox function

# should be available during the Text._get_layout() call, which is

# called within the _get_textbox. So, it would better to move this

# function as a method with some refactoring of _get_layout method.

projected_xs = []

projected_ys = []

theta = np.deg2rad(text.get_rotation())

tr = Affine2D().rotate(-theta)

_, parts, d = text._get_layout(renderer)

for t, wh, x, y in parts:

w, h = wh

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

yt1 -= d

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 = Affine2D().rotate(theta)

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

"""

zorder = 3

_cached = cbook.maxdict(50)

def __repr__(self):

return "Text(%s, %s, %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,

usetex=None, # defaults to rcParams['text.usetex']

wrap=False,

**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 isinstance(fontproperties, str):

fontproperties = FontProperties(fontproperties)

self._text = ''

self.set_text(text)

self.set_color(color)

self.set_usetex(usetex)

self.set_wrap(wrap)

self.set_verticalalignment(verticalalignment)

self.set_horizontalalignment(horizontalalignment)

self._multialignment = multialignment

self._rotation = rotation

self._fontproperties = fontproperties

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)

def update(self, kwargs):

"""

# Update bbox last, as it depends on font properties.

sentinel = object() # bbox can be None, so use another sentinel.

bbox = kwargs.pop("bbox", sentinel)

super().update(kwargs)

if bbox is not sentinel:

self.set_bbox(bbox)

def __getstate__(self):

d = super().__getstate__()

# remove the cached _renderer (if it exists)

d['_renderer'] = None

return d

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_unitless_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))

self.stale = True

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

self.stale = True

def _get_layout(self, renderer):

"""

key = self.get_prop_tup(renderer=renderer)

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))

# Find full vertical extent of font,

# including ascenders and descenders:

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

self._fontproperties,

ismath=False)

offsety = (lp_h - lp_bl) * self._linespacing

baseline = 0

for i, line in enumerate(lines):

clean_line, ismath = self.is_math_text(line, self.get_usetex())

if clean_line:

w, h, d = renderer.get_text_width_height_descent(clean_line,

self._fontproperties,

ismath=ismath)

else:

w, h, d = 0, 0, 0

# 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.

h = max(h, lp_h)

d = max(d, lp_bl)

whs[i] = w, h

baseline = (h - d) - thisy

thisy -= max(offsety, (h - d) * self._linespacing)

horizLayout[i] = thisx, thisy, w, h

thisy -= d

width = max(width, w)

descent = d

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)], float)

cornersHoriz[:, 1] -= descent

# 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

elif valign == 'center_baseline':

offsety = ymin + height - baseline / 2.0

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

elif valign == 'center_baseline':

offsety = (ymin1 + ymax1 - baseline) / 2.0

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, list(zip(lines, whs, xs, ys)), descent

self._cached[key] = ret

return ret

def set_bbox(self, rectprops):

"""

if rectprops is not None:

props = rectprops.copy()

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

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

if boxstyle is None:

boxstyle = "square"

if pad is None:

pad = 4 # points

pad /= self.get_size() # to fraction of font size

else:

if pad is None:

pad = 0.3

# boxstyle could be a callable or a string

if isinstance(boxstyle, str) and "pad" not in boxstyle:

boxstyle += ",pad=%0.2f" % pad

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

self._bbox_patch = FancyBboxPatch(

(0., 0.),

1., 1.,

boxstyle=boxstyle,

bbox_transmuter=bbox_transmuter,

transform=IdentityTransform(),

**props)

else:

self._bbox_patch = None

self._update_clip_properties()

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_unitless_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 = np.deg2rad(self.get_rotation())

tr = 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)

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 = np.deg2rad(self.get_rotation())

tr = 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 _update_clip_properties(self):

clipprops = dict(clip_box=self.clipbox,

clip_path=self._clippath,

clip_on=self._clipon)

if self._bbox_patch:

bbox = self._bbox_patch.update(clipprops)

def set_clip_box(self, clipbox):

"""

super().set_clip_box(clipbox)

self._update_clip_properties()

def set_clip_path(self, path, transform=None):

"""

super().set_clip_path(path, transform)

self._update_clip_properties()

def set_clip_on(self, b):

"""

super().set_clip_on(b)

self._update_clip_properties()

def get_wrap(self):

"""Returns the wrapping state for the text."""

return self._wrap

def set_wrap(self, wrap):

"""Sets the wrapping state for the text.

self._wrap = wrap

def _get_wrap_line_width(self):

"""

x0, y0 = self.get_transform().transform(self.get_position())

figure_box = self.get_figure().get_window_extent()

# Calculate available width based on text alignment

alignment = self.get_horizontalalignment()

self.set_rotation_mode('anchor')

rotation = self.get_rotation()

left = self._get_dist_to_box(rotation, x0, y0, figure_box)

right = self._get_dist_to_box(

(180 + rotation) % 360,

x0,

y0,

figure_box)

if alignment == 'left':

line_width = left

elif alignment == 'right':

line_width = right

else:

line_width = 2 * min(left, right)

return line_width

def _get_dist_to_box(self, rotation, x0, y0, figure_box):

"""

if rotation > 270:

quad = rotation - 270

h1 = y0 / math.cos(math.radians(quad))

h2 = (figure_box.x1 - x0) / math.cos(math.radians(90 - quad))

elif rotation > 180:

quad = rotation - 180

h1 = x0 / math.cos(math.radians(quad))

h2 = y0 / math.cos(math.radians(90 - quad))

elif rotation > 90:

quad = rotation - 90

h1 = (figure_box.y1 - y0) / math.cos(math.radians(quad))

h2 = x0 / math.cos(math.radians(90 - quad))

else:

h1 = (figure_box.x1 - x0) / math.cos(math.radians(rotation))

h2 = (figure_box.y1 - y0) / math.cos(math.radians(90 - rotation))

return min(h1, h2)

def _get_rendered_text_width(self, text):

"""

w, h, d = self._renderer.get_text_width_height_descent(

text,

self.get_fontproperties(),

False)

return math.ceil(w)

def _get_wrapped_text(self):

"""

# Not fit to handle breaking up latex syntax correctly, so

# ignore latex for now.

if self.get_usetex():

return self.get_text()

# Build the line incrementally, for a more accurate measure of length

line_width = self._get_wrap_line_width()

wrapped_str = ""

line = ""

for word in self.get_text().split(' '):

# New lines in the user's test need to force a split, so that it's

# not using the longest current line width in the line being built

sub_words = word.split('\n')

for i in range(len(sub_words)):

current_width = self._get_rendered_text_width(

line + ' ' + sub_words[i])

# Split long lines, and each newline found in the current word

if current_width > line_width or i > 0:

wrapped_str += line + '\n'

line = ""

if line == "":

line = sub_words[i]

else:

line += ' ' + sub_words[i]

return wrapped_str + line

@artist.allow_rasterization

def draw(self, renderer):

"""

if renderer is not None:

self._renderer = renderer

if not self.get_visible():

return

if self.get_text() == '':

return

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

with _wrap_text(self) as textobj:

bbox, info, descent = textobj._get_layout(renderer)

trans = textobj.get_transform()

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

# position in Text, and dash position in TextWithDash:

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

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

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

if not np.isfinite(posx) or not np.isfinite(posy):

_log.warning("posx and posy should be finite values")

return

canvasw, canvash = renderer.get_canvas_width_height()

# draw the FancyBboxPatch

if textobj._bbox_patch:

textobj._draw_bbox(renderer, posx, posy)

gc = renderer.new_gc()

gc.set_foreground(textobj.get_color())

gc.set_alpha(textobj.get_alpha())

gc.set_url(textobj._url)

textobj._set_gc_clip(gc)

angle = textobj.get_rotation()

for line, wh, x, y in info:

mtext = textobj if len(info) == 1 else None

x = x + posx

y = y + posy

if renderer.flipy():

y = canvash - y

clean_line, ismath = textobj.is_math_text(line,

self.get_usetex())

if textobj.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

textrenderer = PathEffectRenderer(

textobj.get_path_effects(), renderer)

else:

textrenderer = renderer

if textobj.get_usetex():

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

textobj._fontproperties, angle,

mtext=mtext)

else:

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

textobj._fontproperties, angle,

ismath=ismath, mtext=mtext)

gc.restore()

renderer.close_group('text')

self.stale = False

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_family(self):

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

return self._fontproperties.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_weight(self):

"Get the font weight as string or number"

return self._fontproperties.get_weight()

def get_stretch(self):

'Get the font stretch as a string or number'

return self._fontproperties.get_stretch()

def get_horizontalalignment(self):

"""

return self._horizontalalignment

def get_unitless_position(self):

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

# This will get the position with all unit information stripped away.

# This is here for convenience since it is done in several locations.

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

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

return x, y

def get_position(self):

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

# This should return the same data (possible unitized) as was

# specified with 'set_x' and 'set_y'.

return self._x, self._y

def get_prop_tup(self, renderer=None):

"""

x, y = self.get_unitless_position()

renderer = renderer or self._renderer

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

self._verticalalignment, self._horizontalalignment,

hash(self._fontproperties),

self._rotation, self._rotation_mode,

self.figure.dpi, weakref.ref(renderer),

self._linespacing

)

def get_text(self):

"Get the text as string"

return self._text

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() == '':

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, descent = self._get_layout(self._renderer)

x, y = self.get_unitless_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_patch is None:

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

else:

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

self._update_clip_properties()

self.stale = True

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

self.stale = True

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

self.stale = True

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

self.stale = True

def set_linespacing(self, spacing):

"""

self._linespacing = spacing

self.stale = True

def set_family(self, fontname):

"""

self._fontproperties.set_family(fontname)

self.stale = True

def set_variant(self, variant):

"""

self._fontproperties.set_variant(variant)

self.stale = True

def set_style(self, fontstyle):

"""

self._fontproperties.set_style(fontstyle)

self.stale = True