Présentation de la boîte à outils axisartist

Le tutoriel de la boîte à outils axisartist.

Avertissement

axisartist utilise une classe Axes personnalisée (dérivée de la classe Axes originale de Matplotlib). Comme effet secondaire, certaines commandes (principalement liées aux ticks) ne fonctionnent pas.

L' axisartist contient une classe Axes personnalisée destinée à prendre en charge les grilles curvilignes (par exemple, le système de coordonnées mondial en astronomie). Contrairement à la classe Axes originale de Matplotlib qui utilise Axes.xaxis et Axes.yaxis pour dessiner des ticks, des ticklines, etc., axisartist utilise un artiste spécial (AxisArtist) qui peut gérer des ticks, des ticklines, etc. pour les systèmes de coordonnées courbes.

Comme il utilise des artistes spéciaux, certaines commandes Matplotlib qui fonctionnent sur Axes.xaxis et Axes.yaxis peuvent ne pas fonctionner.

axeartiste

Le module axisartist fournit une classe Axes personnalisée (et très expérimentale), où chaque axe (gauche, droite, haut et bas) a un artiste associé distinct qui est responsable du dessin de la ligne d'axe, des ticks, des ticklabels et des labels. Vous pouvez également créer votre propre axe, qui peut passer par une position fixe dans les coordonnées des axes ou une position fixe dans les coordonnées des données (c'est-à-dire que l'axe flotte lorsque la limite de vue change).

La classe axes, par défaut, a ses axes x et y invisibles, et a 4 artistes supplémentaires qui sont chargés de dessiner les épines 4 axes en "gauche", "droite", "bas" et "haut". Ils sont accessibles en tant que ax.axis["left"], ax.axis["right"], etc., c'est-à-dire que ax.axis est un dictionnaire qui contient des artistes (notez que ax.axis est toujours une méthode appelable et qu'elle se comporte comme une méthode Axes.axis originale dans Matplotlib).

Pour créer un Axes,

import mpl_toolkits.axisartist as AA
fig = plt.figure()
fig.add_axes([0.1, 0.1, 0.8, 0.8], axes_class=AA.Axes)

ou pour créer une sous-parcelle

fig.add_subplot(111, axes_class=AA.Axes)
# Given that 111 is the default, one can also do
fig.add_subplot(axes_class=AA.Axes)

Par exemple, vous pouvez masquer les tranches droite et supérieure en utilisant :

ax.axis["right"].set_visible(False)
ax.axis["top"].set_visible(False)

Il est également possible d'ajouter un axe horizontal. Par exemple, vous pouvez avoir un axe horizontal à y=0 (en coordonnées de données).

ax.axis["y=0"] = ax.new_floating_axis(nth_coord=0, value=0)

Ou un axe fixe avec un décalage

# make new (right-side) yaxis, but with some offset
ax.axis["right2"] = ax.new_fixed_axis(loc="right", offset=(20, 0))

axisartist avec ParasiteAxes

La plupart des commandes de la boîte à outils axes_grid1 peuvent prendre un argument de mot-clé axes_class et les commandes créent un Axes de la classe donnée. Par exemple, pour créer une sous-parcelle hôte avec axisartist.Axes,

import mpl_toolkits.axisartist as AA
from mpl_toolkits.axes_grid1 import host_subplot

host = host_subplot(111, axes_class=AA.Axes)

Voici un exemple qui utilise ParasiteAxes.

Grille curviligne

La motivation derrière le module AxisArtist est de prendre en charge une grille curviligne et des ticks.

Haches flottantes

AxisArtist prend également en charge les axes flottants dont les axes externes sont définis comme des axes flottants.

espace de noms axisartist

L' espace de noms axisartist inclut une implémentation Axes dérivée. La plus grande différence est que les artistes chargés de tracer la ligne d'axe, les ticks, le ticklabel et les étiquettes d'axe sont séparés de la classe Axis de Matplotlib, qui sont bien plus que des artistes dans le Matplotlib original. Ce changement a été fortement motivé pour prendre en charge la grille curviligne. Voici quelques éléments qui font que mpl_toolkits.axisartist.Axes est différent des axes originaux de Matplotlib.

• Les éléments d'axe (axis line(spine), ticks, ticklabel et axis labels) sont dessinés par une instance AxisArtist. Contrairement à Axis, les axes gauche, droit, supérieur et inférieur sont dessinés par des artistes distincts. Et chacun d'eux peut avoir un emplacement de tique différent et des étiquettes de tiques différentes.

• les lignes de grille sont dessinées par une instance de Gridlines. Le changement a été motivé par le fait qu'en coordonnées curvilignes, une ligne de grille ne peut pas croiser les lignes d'axe (c'est-à-dire, pas de graduations associées). Dans la classe Axes d'origine, les quadrillages sont liés aux graduations.

• les ticklines peuvent être tournées si nécessaire (c'est-à-dire le long du quadrillage)

En résumé, tous ces changements visaient à soutenir

• une grille curviligne.

• un axe flottant

La classe mpl_toolkits.axisartist.Axes définit un attribut d' axe , qui est un dictionnaire d'instances AxisArtist. Par défaut, le dictionnaire a 4 instances AxisArtist, responsables du dessin des axes gauche, droit, bas et haut.

Les attributs xaxis et yaxis sont toujours disponibles, mais ils sont définis comme non visibles. Comme des artistes séparés sont utilisés pour le rendu de l'axe, certaines méthodes liées à l'axe dans Matplotlib peuvent n'avoir aucun effet. En plus des instances AxisArtist, le mpl_toolkits.axisartist.Axes aura l' attribut gridlines (Gridlines), qui dessine évidemment des lignes de grille.

Dans AxisArtist et Gridlines, le calcul de l'emplacement des graduations et de la grille est délégué à une instance de la classe GridHelper. La classe mpl_toolkits.axisartist.Axes utilise GridHelperRectlinear comme assistant de grille. La classe GridHelperRectlinear est un wrapper autour des axes x et y des axes originaux de Matplotlib, et elle était censée fonctionner comme le fonctionnement des axes originaux de Matplotlib. Par exemple, les changements d'emplacement des ticks à l'aide de la méthode set_ticks, etc. devraient fonctionner comme prévu. Mais le changement des propriétés de l'artiste (par exemple, la couleur) ne fonctionnera pas en général, bien que certains efforts aient été faits pour que certains attributs qui changent souvent (couleur, etc.) soient respectés.

AxisArtiste

AxisArtist peut être considéré comme un artiste conteneur avec les attributs suivants qui dessineront des tiques, des étiquettes, etc.

• ligne

• major_ticks, major_ticklabels

• minor_ticks, minor_ticklabels

• décalageTexte

• étiquette

ligne

Dérivé de la classe Line2D. Responsable du dessin d'une ligne vertébrale (?).

major_ticks, minor_ticks

Dérivé de la classe Line2D. Notez que les tiques sont des marqueurs.

major_ticklabels, minor_ticklabels

Dérivé du texte. Notez qu'il ne s'agit pas d'une liste d'artistes de texte, mais d'un seul artiste (similaire à une collection).

étiquette d'axe

Dérivé du texte.

AxisArtists par défaut

Par défaut, les artistes suivants pour l'axe sont définis :

ax.axis["left"], ax.axis["bottom"], ax.axis["right"], ax.axis["top"]

Les ticklabels et axislabel des axes du haut et de droite sont définis comme non visibles.

Par exemple, si vous souhaitez modifier les attributs de couleur de major_ticklabels de l'axe des x inférieur

ax.axis["bottom"].major_ticklabels.set_color("b")

De même, pour rendre les ticklabels invisibles

ax.axis["bottom"].major_ticklabels.set_visible(False)

AxisArtist fournit une méthode d'assistance pour contrôler la visibilité des ticks, ticklabels et label. Pour rendre ticklabel invisible,

ax.axis["bottom"].toggle(ticklabels=False)

Pour rendre toutes les graduations, les étiquettes de graduation et l'étiquette (de l'axe) invisibles

ax.axis["bottom"].toggle(all=False)

Pour tout désactiver mais les tiques sont activées

ax.axis["bottom"].toggle(all=False, ticks=True)

Pour tout activer sauf l'étiquette (axe) désactivée

ax.axis["bottom"].toggle(all=True, label=False)

La méthode __getitem__ de ax.axis peut prendre plusieurs noms d'axe. Par exemple, pour activer les ticklabels des axes "top" et "right",

ax.axis["top", "right"].toggle(ticklabels=True)

Notez que cela renvoie un objet proxy simple qui traduit le code ci-dessus en quelque chose comme ci-dessous.ax.axis["top", "right"]

for n in ["top", "right"]:
    ax.axis[n].toggle(ticklabels=True)

Ainsi, toutes les valeurs de retour dans la boucle for sont ignorées. Et vous ne devriez pas l'utiliser plus qu'une méthode simple.

Comme la liste d'indexation ":" signifie tous les éléments, c'est-à-dire,

ax.axis[:].major_ticks.set_color("r")

change la couleur des ticks dans tous les axes.

Comment faire

1. Changer les emplacements et l'étiquette des ticks.

Identique aux axes originaux de Matplotlib :

ax.set_xticks([1, 2, 3])

2. Modification des propriétés de l'axe comme la couleur, etc.

Modifiez les propriétés des artistes appropriés. Par exemple, pour changer la couleur des ticklabels :

ax.axis["left"].major_ticklabels.set_color("r")

3. Pour modifier les attributs de plusieurs axes :

   ax.axis["left", "bottom"].major_ticklabels.set_color("r")
   

   ou pour changer les attributs de tous les axes :

   ax.axis[:].major_ticklabels.set_color("r")
   

4. Pour modifier la taille du tick (longueur), vous devez utiliser la méthode axis.major_ticks.set_ticksize. Pour changer la direction des ticks (les ticks sont dans la direction opposée des ticklabels par défaut), utilisez la méthode axis.major_ticks.set_tick_out.

   Pour changer le pad entre les ticks et les ticklabels, utilisez la méthode axis.major_ticklabels.set_pad.

   Pour changer le pad entre les ticklabels et l'étiquette de l'axe, utilisez la méthode axis.label.set_pad.

Rotation et alignement des TickLabels

Ceci est également assez différent du Matplotlib standard et peut prêter à confusion. Lorsque vous souhaitez faire pivoter les ticklabels, envisagez d'abord d'utiliser la méthode "set_axis_direction".

ax1.axis["left"].major_ticklabels.set_axis_direction("top")
ax1.axis["right"].label.set_axis_direction("left")

Le paramètre de set_axis_direction est l'un des ["left", "right", "bottom", "top"].

Vous devez comprendre un concept sous-jacent de directions.

• Il existe une direction de référence qui est définie comme la direction de la ligne d'axe avec une coordonnée croissante. Par exemple, la direction de référence de l'axe des x de gauche est de bas en haut.

  La direction, l'angle du texte et les alignements des ticks, ticklabels et axis-label sont déterminés par rapport à la direction de référence

• label_direction et ticklabel_direction sont soit le côté droit (+) de la direction de référence, soit le côté gauche (-).

• les ticks sont dessinés par défaut dans la direction opposée des ticklabels.

• la rotation du texte des ticklabels et de l'étiquette est déterminée en référence à ticklabel_direction ou label_direction , respectivement. La rotation des ticklabels et label est ancrée.

D'autre part, il existe un concept de "axis_direction". Il s'agit d'un paramètre par défaut des propriétés ci-dessus pour chaque axe "bas", "gauche", "haut" et "droit".

?	?	la gauche	fond	droit	Haut
libellé de l'axe	direction	'-'	'+'	'+'	'-'
libellé de l'axe	rotation	180	0	0	180
libellé de l'axe	Virginie	centre	Haut	centre	fond
libellé de l'axe	Ha	droit	centre	droit	centre
ticklabel	direction	'-'	'+'	'+'	'-'
ticklabels	rotation	90	0	-90	180
ticklabel	Ha	droit	centre	droit	centre
ticklabel	Virginie	centre	ligne de base	centre	ligne de base

Et, 'set_axis_direction("top")' signifie ajuster la rotation du texte, etc., pour les paramètres adaptés à l'axe "top". Le concept de direction d'axe peut être plus clair avec un axe courbe.

L'axis_direction peut être ajusté au niveau AxisArtist ou au niveau de ses artistes enfants, c'est-à-dire ticks, ticklabels et axis-label.

ax1.axis["left"].set_axis_direction("top")

change axis_direction de tous les artistes associés avec l'axe "gauche", tandis que

ax1.axis["left"].major_ticklabels.set_axis_direction("top")

modifie l'axis_direction uniquement des major_ticklabels. Notez que set_axis_direction au niveau AxisArtist modifie les ticklabel_direction et label_direction, tandis que la modification de l'axis_direction des ticks, ticklabels et axis-label ne les affecte pas.

Si vous voulez faire des ticks vers l'extérieur et des ticklabels à l'intérieur des axes, utilisez la méthode invert_ticklabel_direction.

ax.axis[:].invert_ticklabel_direction()

Une méthode connexe est "set_tick_out". Il fait des tiques vers l'extérieur (en fait, il fait des tiques dans la direction opposée à la direction par défaut).

ax.axis[:].major_ticks.set_tick_out(True)

Donc, en résumé,

• Les méthodes d'AxisArtist

  • set_axis_direction : "gauche", "droite", "bas" ou "haut"

  • set_ticklabel_direction : "+" ou "-"

  • set_axislabel_direction : "+" ou "-"

  • invert_ticklabel_direction

• Méthodes des ticks (major_ticks et minor_ticks)

  • set_tick_out : vrai ou faux

  • set_ticksize : taille en points

• Les méthodes de TickLabels (major_ticklabels et minor_ticklabels)

  • set_axis_direction : "gauche", "droite", "bas" ou "haut"

  • set_rotation : angle par rapport à la direction de référence

  • set_ha et set_va : voir ci-dessous

• Méthodes d'AxisLabels (label)

  • set_axis_direction : "gauche", "droite", "bas" ou "haut"

  • set_rotation : angle par rapport à la direction de référence

  • set_ha et set_va

Ajustement de l'alignement des ticklabels

L'alignement des TickLabels est traité spécialement. Voir ci-dessous

Patin de réglage

Pour changer le pad entre les ticks et les ticklabels

ax.axis["left"].major_ticklabels.set_pad(10)

Ou ticklabels et axis-label

ax.axis["left"].label.set_pad(10)

GridHelper

Pour définir réellement une coordonnée curviligne, vous devez utiliser votre propre assistant de grille. Une version généralisée de la classe grid helper est fournie et cette classe devrait suffire dans la plupart des cas. Un utilisateur peut fournir deux fonctions qui définissent une transformation (et sa paire inverse) de la coordonnée courbe à la coordonnée (rectiligne) de l'image. Notez que bien que les graduations et les grilles soient dessinées pour des coordonnées courbes, la transformation de données des axes elle-même (ax.transData) est toujours une coordonnée rectiligne (image).

from mpl_toolkits.axisartist.grid_helper_curvelinear \
     import GridHelperCurveLinear
from mpl_toolkits.axisartist import Axes

# from curved coordinate to rectlinear coordinate.
def tr(x, y):
    x, y = np.asarray(x), np.asarray(y)
    return x, y-x

# from rectlinear coordinate to curved coordinate.
def inv_tr(x, y):
    x, y = np.asarray(x), np.asarray(y)
    return x, y+x

grid_helper = GridHelperCurveLinear((tr, inv_tr))

fig.add_subplot(axes_class=Axes, grid_helper=grid_helper)

Vous pouvez utiliser l'instance Transform de Matplotlib à la place (mais une transformation inverse doit être définie). Souvent, la plage de coordonnées dans un système de coordonnées courbe peut avoir une plage limitée ou peut avoir des cycles. Dans ces cas, une version plus personnalisée de l'assistant de grille est requise.

import mpl_toolkits.axisartist.angle_helper as angle_helper

# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()

# extreme finder: find a range of coordinate.
# 20, 20: number of sampling points along x, y direction
# The first coordinate (longitude, but theta in polar)
#   has a cycle of 360 degree.
# The second coordinate (latitude, but radius in polar)  has a minimum of 0
extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
                                                 lon_cycle = 360,
                                                 lat_cycle = None,
                                                 lon_minmax = None,
                                                 lat_minmax = (0, np.inf),
                                                 )

# Find a grid values appropriate for the coordinate (degree,
# minute, second). The argument is a approximate number of grids.
grid_locator1 = angle_helper.LocatorDMS(12)

# And also uses an appropriate formatter.  Note that the acceptable Locator
# and Formatter classes are different than that of Matplotlib's, and you
# cannot directly use Matplotlib's Locator and Formatter here (but may be
# possible in the future).
tick_formatter1 = angle_helper.FormatterDMS()

grid_helper = GridHelperCurveLinear(tr,
                                    extreme_finder=extreme_finder,
                                    grid_locator1=grid_locator1,
                                    tick_formatter1=tick_formatter1
                                    )

Là encore, la transData des axes est toujours une coordonnée rectiligne (coordonnée image). Vous pouvez effectuer manuellement la conversion entre deux coordonnées, ou vous pouvez utiliser Parasite Axes pour plus de commodité. :

ax1 = SubplotHost(fig, 1, 2, 2, grid_helper=grid_helper)

# A parasite axes with given transform
ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
# note that ax2.transData == tr + ax1.transData
# Anything you draw in ax2 will match the ticks and grids of ax1.
ax1.parasites.append(ax2)

FloatingAxis

Un axe flottant est un axe dont l'une des coordonnées des données est fixe, c'est-à-dire que son emplacement n'est pas fixe dans la coordonnée des axes mais change lorsque les limites des données des axes changent. Un axe flottant peut être créé à l'aide de la méthode new_floating_axis . Cependant, il est de votre responsabilité que l'AxisArtist résultant soit correctement ajouté aux axes. Une méthode recommandée consiste à l'ajouter en tant qu'élément de l'attribut d'axe d'Axes :

# floating axis whose first (index starts from 0) coordinate
# (theta) is fixed at 60

ax1.axis["lat"] = axis = ax1.new_floating_axis(0, 60)
axis.label.set_text(r"$\theta = 60^{\circ}$")
axis.label.set_visible(True)

Voir le premier exemple de cette page.

Limitations actuelles et TODO

Le code a besoin de plus de raffinement. Voici une liste incomplète des problèmes et TODO

• Pas de moyen facile de prendre en charge un emplacement de tique personnalisé par l'utilisateur (pour la grille curviligne). Une nouvelle classe Locator doit être créée.

• FloatingAxis peut avoir des limites de coordonnées, par exemple, un axe flottant de x = 0, mais y ne s'étend que de 0 à 1.

• L'emplacement de l'étiquette de l'axe de FloatingAxis doit éventuellement être donné sous forme de valeur de coordonnée. ex, un axe flottant de x=0 avec étiquette à y=1