Zone de texte avec retour à la ligne dans matplotlib?

Le contenu de cette réponse ont été fusionnées dans mpl maître dans https://github.com/matplotlib/matplotlib/pull/4342 et sera dans la prochaine version de fonctionnalités.

---

Wow... C'est un problème épineux... (Et il expose beaucoup de limites dans matplotlib de rendu de texte...)

Cela devrait (j'.m.o.) être quelque chose que matplotlib a intégré, mais il ne le fait pas. Il y a eu quelques discussions à ce sujet sur la liste de diffusion, mais aucune des solutions que j'ai pu trouver à automatique de l'habillage de texte.

Si, tout d'abord, il n'y a aucun moyen de déterminer la taille (en pixels) de la chaîne de texte avant qu'il soit établi dans matplotlib. Ce n'est pas trop grand d'un problème, comme on peut le dessiner simplement, prenez la taille, et puis redessiner le texte enveloppé. (C'est cher, mais pas trop mauvais)

Le problème suivant est que les personnages n'ont pas une largeur fixe en pixels, de sorte que la recouvrant d'une chaîne de texte à un nombre donné de caractères ne reflétera pas forcément une largeur lors du rendu. Ce n'est pas un énorme problème.

Au-delà, nous ne pouvons pas le faire une fois... Sinon, il sera emballé correctement quand élaboré la première fois (sur l'écran, par exemple), mais pas si nouveau tiré (lorsque la figure est redimensionnée ou enregistrée comme une image avec une autre DPI de l'écran). Ce n'est pas un énorme problème, comme on peut il suffit de connecter une fonction de rappel à la matplotlib attirer l'événement.

En tout cas cette solution est imparfaite, mais il devrait fonctionner dans la plupart des situations. Je ne cherche pas à rendre compte de tex-rendus des chaînes, tout tendu de polices ou fontes avec un aspect inhabituel ratio. Cependant, il doit maintenant gérer correctement le texte pivoté.

Cependant, Il doit tenter automatiquement automatiquement n'importe quel texte les objets en de multiples sous-intrigues, selon les chiffres que vous connectez le on_draw rappel... Il sera imparfaite dans de nombreux cas, mais il fait un travail décent.

import matplotlib.pyplot as plt
def main():
fig = plt.figure()
plt.axis([0, 10, 0, 10])
t = "This is a really long string that I'd rather have wrapped so that it"\
" doesn't go outside of the figure, but if it's long enough it will go"\
" off the top or bottom!"
plt.text(4, 1, t, ha='left', rotation=15)
plt.text(5, 3.5, t, ha='right', rotation=-15)
plt.text(5, 10, t, fontsize=18, ha='center', va='top')
plt.text(3, 0, t, family='serif', style='italic', ha='right')
plt.title("This is a really long title that I want to have wrapped so it"\
" does not go outside the figure boundaries", ha='center')
# Now make the text auto-wrap...
fig.canvas.mpl_connect('draw_event', on_draw)
plt.show()
def on_draw(event):
"""Auto-wraps all text objects in a figure at draw-time"""
import matplotlib as mpl
fig = event.canvas.figure
# Cycle through all artists in all the axes in the figure
for ax in fig.axes:
for artist in ax.get_children():
# If it's a text artist, wrap it...
if isinstance(artist, mpl.text.Text):
autowrap_text(artist, event.renderer)
# Temporarily disconnect any callbacks to the draw event...
# (To avoid recursion)
func_handles = fig.canvas.callbacks.callbacks[event.name]
fig.canvas.callbacks.callbacks[event.name] = {}
# Re-draw the figure..
fig.canvas.draw()
# Reset the draw event callbacks
fig.canvas.callbacks.callbacks[event.name] = func_handles
def autowrap_text(textobj, renderer):
"""Wraps the given matplotlib text object so that it exceed the boundaries
of the axis it is plotted in."""
import textwrap
# Get the starting position of the text in pixels...
x0, y0 = textobj.get_transform().transform(textobj.get_position())
# Get the extents of the current axis in pixels...
clip = textobj.get_axes().get_window_extent()
# Set the text to rotate about the left edge (doesn't make sense otherwise)
textobj.set_rotation_mode('anchor')
# Get the amount of space in the direction of rotation to the left and 
# right of x0, y0 (left and right are relative to the rotation, as well)
rotation = textobj.get_rotation()
right_space = min_dist_inside((x0, y0), rotation, clip)
left_space = min_dist_inside((x0, y0), rotation - 180, clip)
# Use either the left or right distance depending on the horiz alignment.
alignment = textobj.get_horizontalalignment()
if alignment is 'left':
new_width = right_space 
elif alignment is 'right':
new_width = left_space
else:
new_width = 2 * min(left_space, right_space)
# Estimate the width of the new size in characters...
aspect_ratio = 0.5 # This varies with the font!! 
fontsize = textobj.get_size()
pixels_per_char = aspect_ratio * renderer.points_to_pixels(fontsize)
# If wrap_width is < 1, just make it 1 character
wrap_width = max(1, new_width // pixels_per_char)
try:
wrapped_text = textwrap.fill(textobj.get_text(), wrap_width)
except TypeError:
# This appears to be a single word
wrapped_text = textobj.get_text()
textobj.set_text(wrapped_text)
def min_dist_inside(point, rotation, box):
"""Gets the space in a given direction from "point" to the boundaries of
"box" (where box is an object with x0, y0, x1, & y1 attributes, point is a
tuple of x,y, and rotation is the angle in degrees)"""
from math import sin, cos, radians
x0, y0 = point
rotation = radians(rotation)
distances = []
threshold = 0.0001 
if cos(rotation) > threshold: 
# Intersects the right axis
distances.append((box.x1 - x0) / cos(rotation))
if cos(rotation) < -threshold: 
# Intersects the left axis
distances.append((box.x0 - x0) / cos(rotation))
if sin(rotation) > threshold: 
# Intersects the top axis
distances.append((box.y1 - y0) / sin(rotation))
if sin(rotation) < -threshold: 
# Intersects the bottom axis
distances.append((box.y0 - y0) / sin(rotation))
return min(distances)
if __name__ == '__main__':
main()

Son été à peu près cinq ans, mais il ne semble pas encore être une excellente façon de le faire. Voici ma version de la solution retenue. Mon but était de permettre au pixel près d'habillage pour être appliquée de manière sélective à l'individu occurrences de texte. J'ai également créé une zone de texte simple() qui permet de convertir tous les axes dans une zone de texte avec des marges personnalisées et de l'alignement.

Au lieu de supposer une police particulière ratio d'aspect ou de largeur moyenne, en fait, je tire la corde un mot à la fois et d'insérer des retours à la ligne une fois que le seuil est atteint. C'est horriblement lent par rapport à la approximations, mais se sent encore assez accrocheur pour les chaînes de <200 mots.

# Text Wrapping
# Defines wrapText which will attach an event to a given mpl.text object,
# wrapping it within the parent axes object.  Also defines a the convenience
# function textBox() which effectively converts an axes to a text box.
def wrapText(text, margin=4):
""" Attaches an on-draw event to a given mpl.text object which will
automatically wrap its string wthin the parent axes object.
The margin argument controls the gap between the text and axes frame
in points.
"""
ax = text.get_axes()
margin = margin / 72 * ax.figure.get_dpi()
def _wrap(event):
"""Wraps text within its parent axes."""
def _width(s):
"""Gets the length of a string in pixels."""
text.set_text(s)
return text.get_window_extent().width
# Find available space
clip = ax.get_window_extent()
x0, y0 = text.get_transform().transform(text.get_position())
if text.get_horizontalalignment() == 'left':
width = clip.x1 - x0 - margin
elif text.get_horizontalalignment() == 'right':
width = x0 - clip.x0 - margin
else:
width = (min(clip.x1 - x0, x0 - clip.x0) - margin) * 2
# Wrap the text string
words = [''] + _splitText(text.get_text())[::-1]
wrapped = []
line = words.pop()
while words:
line = line if line else words.pop()
lastLine = line
while _width(line) <= width:
if words:
lastLine = line
line += words.pop()
# Add in any whitespace since it will not affect redraw width
while words and (words[-1].strip() == ''):
line += words.pop()
else:
lastLine = line
break
wrapped.append(lastLine)
line = line[len(lastLine):]
if not words and line:
wrapped.append(line)
text.set_text('\n'.join(wrapped))
# Draw wrapped string after disabling events to prevent recursion
handles = ax.figure.canvas.callbacks.callbacks[event.name]
ax.figure.canvas.callbacks.callbacks[event.name] = {}
ax.figure.canvas.draw()
ax.figure.canvas.callbacks.callbacks[event.name] = handles
ax.figure.canvas.mpl_connect('draw_event', _wrap)
def _splitText(text):
""" Splits a string into its underlying chucks for wordwrapping.  This
mostly relies on the textwrap library but has some additional logic to
avoid splitting latex/mathtext segments.
"""
import textwrap
import re
math_re = re.compile(r'(?<!\\)\$')
textWrapper = textwrap.TextWrapper()
if len(math_re.findall(text)) <= 1:
return textWrapper._split(text)
else:
chunks = []
for n, segment in enumerate(math_re.split(text)):
if segment and (n % 2):
# Mathtext
chunks.append('${}$'.format(segment))
else:
chunks += textWrapper._split(segment)
return chunks
def textBox(text, axes, ha='left', fontsize=12, margin=None, frame=True, **kwargs):
""" Converts an axes to a text box by removing its ticks and creating a
wrapped annotation.
"""
if margin is None:
margin = 6 if frame else 0
axes.set_xticks([])
axes.set_yticks([])
axes.set_frame_on(frame)
an = axes.annotate(text, fontsize=fontsize, xy=({'left':0, 'right':1, 'center':0.5}[ha], 1), ha=ha, va='top',
xytext=(margin, -margin), xycoords='axes fraction', textcoords='offset points', **kwargs)
wrapText(an, margin=margin)
return an

Utilisation:

ax = plot.plt.figure(figsize=(6, 6)).add_subplot(111)
an = ax.annotate(t, fontsize=12, xy=(0.5, 1), ha='center', va='top', xytext=(0, -6),
xycoords='axes fraction', textcoords='offset points')
wrapText(an)

J'ai laissé tomber quelques fonctionnalités qui n'étaient pas aussi important pour moi. Le redimensionnement échouera comme chaque appel à _wrap() insère des sauts de ligne supplémentaires dans la chaîne, mais n'a aucun moyen de les enlever. Cela peut être résolu en enlevant tous les caractères \n dans le _wrap la fonction ou à l'entreposage de la chaîne d'origine quelque part et de "réinitialiser" le texte de l'instance entre les enveloppements.