"""

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

x_box, y_box = Affine2D().rotate(theta).transform((xt_box, yt_box))

"""Call ``renderer.get_text_width_height_descent``, caching the results."""

# Cached based on a copy of fontprop so that later in-place mutations of

# the passed-in argument do not mess up the cache.

return _get_text_metrics_with_cache_impl(

"""Handle storing and drawing of text in window or data coordinates."""

zorder = 3

_charsize_cache = dict()

def __repr__(self):

return f"Text({self._x}, {self._y}, {self._text!r})"

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,

transform_rotates_text=False,

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

**kwargs

):

"""

super().__init__()

self._x, self._y = x, y

self._text = ''

self._reset_visual_defaults(

text=text,

color=color,

fontproperties=fontproperties,

usetex=usetex,

parse_math=parse_math,

wrap=wrap,

verticalalignment=verticalalignment,

horizontalalignment=horizontalalignment,

multialignment=multialignment,

rotation=rotation,

transform_rotates_text=transform_rotates_text,

linespacing=linespacing,

rotation_mode=rotation_mode,

)

self.update(kwargs)

def _reset_visual_defaults(

self,

text='',

color=None,

fontproperties=None,

usetex=None,

parse_math=None,

wrap=False,

verticalalignment='baseline',

horizontalalignment='left',

multialignment=None,

rotation=None,

transform_rotates_text=False,

linespacing=None,

rotation_mode=None,

):

self.set_text(text)

self.set_color(

color if color is not None else mpl.rcParams["text.color"])

self.set_fontproperties(fontproperties)

self.set_usetex(usetex)

self.set_parse_math(parse_math if parse_math is not None else

mpl.rcParams['text.parse_math'])

self.set_wrap(wrap)

self.set_verticalalignment(verticalalignment)

self.set_horizontalalignment(horizontalalignment)

self._multialignment = multialignment

self.set_rotation(rotation)

self._transform_rotates_text = transform_rotates_text

self._bbox_patch = None # a FancyBboxPatch instance

self._renderer = None

if linespacing is None:

linespacing = 1.2 # Maybe use rcParam later.

self.set_linespacing(linespacing)

self.set_rotation_mode(rotation_mode)

def update(self, kwargs):

# docstring inherited

kwargs = cbook.normalize_kwargs(kwargs, Text)

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

# Update fontproperties first, as it has lowest priority.

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

if fontproperties is not sentinel:

self.set_fontproperties(fontproperties)

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

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

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

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

return False, {}

# Explicitly use Text.get_window_extent(self) and not

# self.get_window_extent() so that Annotation.contains does not

# accidentally cover the entire annotation bounding box.

bbox = Text.get_window_extent(self)

inside = (bbox.x0 <= mouseevent.x <= bbox.x1

and bbox.y0 <= mouseevent.y <= bbox.y1)

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

"""

x, y = self.get_unitless_position()

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

def _get_multialignment(self):

if self._multialignment is not None:

return self._multialignment

else:

return self._horizontalalignment

def _char_index_at(self, x):

"""

if not self._text:

return 0

text = self._text

fontproperties = str(self._fontproperties)

if fontproperties not in Text._charsize_cache:

Text._charsize_cache[fontproperties] = dict()

charsize_cache = Text._charsize_cache[fontproperties]

for char in set(text):

if char not in charsize_cache:

self.set_text(char)

bb = self.get_window_extent()

charsize_cache[char] = bb.x1 - bb.x0

self.set_text(text)

bb = self.get_window_extent()

size_accum = np.cumsum([0] + [charsize_cache[x] for x in text])

std_x = x - bb.x0

return (np.abs(size_accum - std_x)).argmin()

def get_rotation(self):

"""Return the text angle in degrees between 0 and 360."""

if self.get_transform_rotates_text():

return self.get_transform().transform_angles(

[self._rotation], [self.get_unitless_position()]).item(0)

else:

return self._rotation

def get_transform_rotates_text(self):

"""

return self._transform_rotates_text

def set_rotation_mode(self, m):

"""

_api.check_in_list(["anchor", "default", None], rotation_mode=m)

self._rotation_mode = m

self.stale = True

def get_rotation_mode(self):

"""Return the text rotation mode."""

return self._rotation_mode

def update_from(self, other):

# docstring inherited

super().update_from(other)

self._color = other._color

self._multialignment = other._multialignment

self._verticalalignment = other._verticalalignment

self._horizontalalignment = other._horizontalalignment

self._fontproperties = other._fontproperties.copy()

self._usetex = other._usetex

self._rotation = other._rotation

self._transform_rotates_text = other._transform_rotates_text

self._picker = other._picker

self._linespacing = other._linespacing

self.stale = True

def _get_layout(self, renderer):

"""

thisx, thisy = 0.0, 0.0

lines = self._get_wrapped_text().split("\n") # Ensures lines is not empty.

ws = []

hs = []

xs = []

ys = []

# Full vertical extent of font, including ascenders and descenders:

_, lp_h, lp_d = _get_text_metrics_with_cache(

renderer, "lp", self._fontproperties,

ismath="TeX" if self.get_usetex() else False, dpi=self.figure.dpi)

min_dy = (lp_h - lp_d) * self._linespacing

for i, line in enumerate(lines):

clean_line, ismath = self._preprocess_math(line)

if clean_line:

w, h, d = _get_text_metrics_with_cache(

renderer, clean_line, self._fontproperties,

ismath=ismath, dpi=self.figure.dpi)

else:

w = h = d = 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_d)

ws.append(w)

hs.append(h)

# Metrics of the last line that are needed later:

baseline = (h - d) - thisy

if i == 0:

# position at baseline

thisy = -(h - d)

else:

# put baseline a good distance from bottom of previous line

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

xs.append(thisx) # == 0.

ys.append(thisy)

thisy -= d

# Metrics of the last line that are needed later:

descent = d

# Bounding box definition:

width = max(ws)

xmin = 0

xmax = width

ymax = 0

ymin = ys[-1] - descent # baseline of last line minus its descent

# get the rotation matrix

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

# now offset the individual text lines within the box

malign = self._get_multialignment()

if malign == 'left':

offset_layout = [(x, y) for x, y in zip(xs, ys)]

elif malign == 'center':

offset_layout = [(x + width / 2 - w / 2, y)

for x, y, w in zip(xs, ys, ws)]

elif malign == 'right':

offset_layout = [(x + width - w, y)

for x, y, w in zip(xs, ys, ws)]

# the corners of the unrotated bounding box

corners_horiz = np.array(

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

# now rotate the bbox

corners_rotated = M.transform(corners_horiz)

# compute the bounds of the rotated box

xmin = corners_rotated[:, 0].min()

xmax = corners_rotated[:, 0].max()

ymin = corners_rotated[:, 1].min()

ymax = corners_rotated[:, 1].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 + xmax) / 2

elif halign == 'right':

offsetx = xmax

else:

offsetx = xmin

if valign == 'center':

offsety = (ymin + ymax) / 2

elif valign == 'top':

offsety = ymax

elif valign == 'baseline':

offsety = ymin + descent

elif valign == 'center_baseline':

offsety = ymin + height - baseline / 2.0

else:

offsety = ymin

else:

xmin1, ymin1 = corners_horiz[0]

xmax1, ymax1 = corners_horiz[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 = ymax1 - baseline / 2.0

else:

offsety = ymin1

offsetx, offsety = M.transform((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(offset_layout) - (offsetx, offsety)

return bbox, list(zip(lines, zip(ws, hs), *xys.T)), descent

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

self._bbox_patch = FancyBboxPatch(

(0, 0), 1, 1,

boxstyle=boxstyle, 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:

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

# position in Text:

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

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

posx, posy = self.get_transform().transform((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)

self._bbox_patch.set_transform(

Affine2D()

.rotate_deg(self.get_rotation())

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

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

self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

def _update_clip_properties(self):

clipprops = dict(clip_box=self.clipbox,

clip_path=self._clippath,

clip_on=self._clipon)

if self._bbox_patch:

self._bbox_patch.update(clipprops)

def set_clip_box(self, clipbox):

# docstring inherited.

super().set_clip_box(clipbox)

self._update_clip_properties()

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

# docstring inherited.

super().set_clip_path(path, transform)

self._update_clip_properties()

def set_clip_on(self, b):

# docstring inherited.

super().set_clip_on(b)

self._update_clip_properties()

def get_wrap(self):

"""Return whether the text can be wrapped."""

return self._wrap

def set_wrap(self, wrap):

"""

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

"""

if not self.get_wrap():

return self.get_text()

# 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_lines = []

# New lines in the user's text force a split

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

# Now wrap each individual unwrapped line

for unwrapped_line in unwrapped_lines:

sub_words = unwrapped_line.split(' ')

# Remove items from sub_words as we go, so stop when empty

while len(sub_words) > 0:

if len(sub_words) == 1:

# Only one word, so just add it to the end

wrapped_lines.append(sub_words.pop(0))

continue

for i in range(2, len(sub_words) + 1):

# Get width of all words up to and including here

line = ' '.join(sub_words[:i])

current_width = self._get_rendered_text_width(line)

# If all these words are too wide, append all not including

# last word

if current_width > line_width:

wrapped_lines.append(' '.join(sub_words[:i - 1]))

sub_words = sub_words[i - 1:]

break

# Otherwise if all words fit in the width, append them all

elif i == len(sub_words):

wrapped_lines.append(' '.join(sub_words[:i]))

sub_words = []

break

return '\n'.join(wrapped_lines)

@artist.allow_rasterization

def draw(self, renderer):

# docstring inherited

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 self._cm_set(text=self._get_wrapped_text()):

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

trans = self.get_transform()

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

# position in Text:

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

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

posx, posy = trans.transform((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()

# Update the location and size of the bbox

# (`.patches.FancyBboxPatch`), and draw it.

if self._bbox_patch:

self.update_bbox_position_size(renderer)

self._bbox_patch.draw(renderer)

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)

angle = self.get_rotation()

for line, wh, x, y in info:

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

x = x + posx

y = y + posy

if renderer.flipy():

y = canvash - y

clean_line, ismath = self._preprocess_math(line)

if self.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

textrenderer = PathEffectRenderer(

self.get_path_effects(), renderer)

else:

textrenderer = renderer

if self.get_usetex():

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

self._fontproperties, angle,

mtext=mtext)

else:

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

self._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 `.font_manager.FontProperties`."""

return self._fontproperties

def get_fontfamily(self):

"""

return self._fontproperties.get_family()

def get_fontname(self):

"""

return self._fontproperties.get_name()

def get_fontstyle(self):

"""

return self._fontproperties.get_style()

def get_fontsize(self):

"""

return self._fontproperties.get_size_in_points()

def get_fontvariant(self):

"""

return self._fontproperties.get_variant()

def get_fontweight(self):

"""

return self._fontproperties.get_weight()

def get_stretch(self):

"""

return self._fontproperties.get_stretch()

def get_horizontalalignment(self):

"""

return self._horizontalalignment

def get_unitless_position(self):

"""Return the (x, y) unitless position of the text."""

# 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 (x, y) position of the text."""

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

# specified with 'set_x' and 'set_y'.

return self._x, self._y

def get_text(self):

"""Return the text string."""

return self._text

def get_verticalalignment(self):

"""

return self._verticalalignment

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

"""

if not self.get_visible():

return Bbox.unit()

if dpi is None:

dpi = self.figure.dpi

if self.get_text() == '':

with cbook._setattr_cm(self.figure, dpi=dpi):

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:

self._renderer = self.figure._get_renderer()

if self._renderer is None:

raise RuntimeError(

"Cannot get window extent of text w/o renderer. You likely "

"want to call 'figure.draw_without_rendering()' first.")

with cbook._setattr_cm(self.figure, dpi=dpi):

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

x, y = self.get_unitless_position()

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

bbox = bbox.translated(x, y)

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

"""

# "auto" is only supported by axisartist, but we can just let it error

# out at draw time for simplicity.

if not cbook._str_equal(color, "auto"):

mpl.colors._check_color_like(color=color)

self._color = color

self.stale = True

def set_horizontalalignment(self, align):

"""

_api.check_in_list(['center', 'right', 'left'], align=align)

self._horizontalalignment = align

self.stale = True

def set_multialignment(self, align):

"""

_api.check_in_list(['center', 'right', 'left'], align=align)

self._multialignment = align

self.stale = True

def set_linespacing(self, spacing):