Aperçu de mpl_toolkits.axes_grid1

axes_grid1offre les fonctionnalités suivantes :

• Classes d'assistance ( ImageGrid , RGBAxes , AxesDivider ) pour faciliter la disposition des axes affichant des images avec un rapport d'aspect fixe tout en satisfaisant des contraintes supplémentaires (faire correspondre les hauteurs d'une barre de couleurs et d'une image, ou fixer le rembourrage entre les images) ;

• ParasiteAxes (fonctionnalités de type twinx/twiny afin que vous puissiez tracer différentes données (par exemple, différentes échelles y) dans un même Axes) ;

• AnchoredArtists (artistes personnalisés qui sont placés à une position ancrée, de la même manière que les légendes).

axes_grid1

Grille d'image

Dans Matplotlib, l'emplacement et la taille des axes sont généralement spécifiés en coordonnées de figure normalisées (0 = en bas à gauche, 1 = en haut à droite), ce qui rend difficile l'obtention d'un remplissage fixe (absolu) entre les images. ImageGridpeut être utilisé pour réaliser un tel rembourrage ; voir ses docs pour des informations détaillées sur l'API.

• La position de chaque axe est déterminée au moment du dessin (voir AxesDivider ), de sorte que la taille de la grille entière tient dans le rectangle donné (comme l'aspect des axes). Notez que dans cet exemple, les remplissages entre les axes sont fixes même si vous modifiez la taille de la figure.

• Les axes d'une même colonne partagent leur axe des x et les axes d'une même ligne partagent leur axe des y (au sens de sharex, sharey). De plus, les axes de la même colonne ont tous la même largeur et les axes de la même ligne ont tous la même hauteur. Ces largeurs et hauteurs sont mises à l'échelle proportionnellement aux limites de vue des axes (xlim ou ylim).

  

Les exemples ci-dessous montrent ce que vous pouvez faire avec ImageGrid.

AxesDivider Classe

Dans les coulisses, ImageGrid (et RGBAxes, décrit ci-dessous) s'appuient sur AxesDivider, dont le rôle est de calculer l'emplacement des axes au moment du dessin.

Les utilisateurs n'ont généralement pas besoin d'instancier directement les séparateurs en appelant AxesDivider; à la place, make_axes_locatablepeut être utilisé pour créer un diviseur pour un Axes :

ax = subplot(1, 1, 1)
divider = make_axes_locatable(ax)

AxesDivider.append_axespeut ensuite être utilisé pour créer un nouvel axe sur un côté donné ("gauche", "droite", "haut", "bas") des axes d'origine.

colorbar dont la hauteur (ou la largeur) est synchronisée avec les axes principaux

scatter_hist.py avec AxesDivider

L' exemple de diagramme de dispersion avec histogrammes peut être réécrit en utilisant make_axes_locatable:

axScatter = plt.subplot()
axScatter.scatter(x, y)
axScatter.set_aspect(1.)

# create new axes on the right and on the top of the current axes.
divider = make_axes_locatable(axScatter)
axHistx = divider.append_axes("top", size=1.2, pad=0.1, sharex=axScatter)
axHisty = divider.append_axes("right", size=1.2, pad=0.1, sharey=axScatter)

# the scatter plot:
# histograms
bins = np.arange(-lim, lim + binwidth, binwidth)
axHistx.hist(x, bins=bins)
axHisty.hist(y, bins=bins, orientation='horizontal')

Voir le code source complet ci-dessous.

L' histogramme de dispersion (axes localisables) utilisant AxesDivider présente certains avantages par rapport au diagramme de dispersion d'origine avec des histogrammes dans Matplotlib. Par exemple, vous pouvez définir le rapport d'aspect du nuage de points, même si l'axe des x ou l'axe des y est partagé en conséquence.

ParasiteAxes

Le ParasiteAxes est un Axes dont l'emplacement est identique à ses axes hôtes. L'emplacement est ajusté au moment du dessin, il fonctionne donc même si l'hôte change d'emplacement (par exemple, les images).

Dans la plupart des cas, vous créez d'abord un axe hôte, qui fournit quelques méthodes pouvant être utilisées pour créer des axes parasites. Ce sont twinx, twiny(qui sont similaires à twinxet twinydans la matplotlib) et twin. twinprend une transformation arbitraire qui mappe entre les coordonnées de données des axes hôtes et les axes parasites. Ladraw méthode des axes parasites ne sont jamais appelées. Au lieu de cela, les axes hôtes collectent les artistes dans les axes parasites et les dessinent comme s'ils appartenaient aux axes hôtes, c'est-à-dire que les artistes dans les axes parasites sont fusionnés avec ceux des axes hôtes puis dessinés selon leur zorder. Les axes hôtes et parasites modifient certains comportements des axes. Par exemple, le cycle de couleur des tracés est partagé entre l'hôte et les parasites. De plus, la commande de légende dans l'hôte crée une légende qui inclut des lignes dans les axes parasites. Pour créer un axe hôte, vous pouvez utiliser host_subplotou host_axescommander.

Exemple 1. twinx

Exemple 2. jumeau

twinsans argument de transformation suppose que les axes parasites ont la même transformation de données que l'hôte. Cela peut être utile lorsque vous souhaitez que l'axe supérieur (ou droit) ait différents emplacements de graduation, étiquettes de graduation ou formateur de graduation pour l'axe inférieur (ou gauche).

ax2 = ax.twin() # now, ax2 is responsible for "top" axis and "right" axis
ax2.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi],
               labels=["0", r"$\frac{1}{2}\pi$",
                       r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])

Un exemple plus sophistiqué utilisant twin. Notez que si vous modifiez la limite x dans les axes hôtes, la limite x des axes parasites changera en conséquence.

Artistes ancrés

axes_grid1.anchored_artistsest une collection d'artistes dont la localisation est ancrée à la (axes) bbox, à l'instar des légendes. Ces artistes dérivent de offsetbox.OffsetBox, et l'artiste doit être dessiné dans les coordonnées de la toile. La prise en charge des transformations arbitraires est limitée. Par exemple, l'ellipse dans l'exemple ci-dessous aura une largeur et une hauteur en coordonnées de données.

Localisateur d'encart

Voir également

Axes.inset_axeset Axes.indicate_inset_zoomdans la bibliothèque principale.

axes_grid1.inset_locatorfournit des classes et des fonctions d'assistance pour placer des axes incrustés à une position ancrée des axes parents, de la même manière que AnchoredArtist.

inset_locator.inset_axescrée un axe d'encart dont la taille est soit fixe, soit une proportion fixe des axes parents :

inset_axes = inset_axes(parent_axes,
                        width="30%",  # width = 30% of parent_bbox
                        height=1.,  # height = 1 inch
                        loc='lower left')

crée un insert axes dont la largeur est de 30% des axes parents et dont la hauteur est fixée à 1 pouce.

inset_locator.zoomed_inset_axescrée un axe d'encart dont l'échelle de données est celle des axes parents multipliée par un certain facteur, par exemple

inset_axes = zoomed_inset_axes(ax,
                               0.5,  # zoom = 0.5
                               loc='upper right')

crée un axe d'encart dont l'échelle des données correspond à la moitié des axes parents. Cela peut être utile pour marquer la zone zoomée sur les axes parent :

inset_locator.mark_insetpermet de marquer l'emplacement de la zone représentée par les axes en médaillon :

RVB Axes

RGBAxes est une classe d'assistance pour afficher facilement des images composites RVB. Comme ImageGrid, l'emplacement des axes est ajusté de sorte que la zone qu'ils occupent tienne dans un rectangle donné. De plus, l'axe des x et l'axe des y de chaque axe sont partagés.

from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes

fig = plt.figure()
ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0)
r, g, b = get_rgb()  # r, g, b are 2D images.
ax.imshow_rgb(r, g, b)

Diviseur d'axes

Le mpl_toolkits.axes_grid1.axes_dividermodule fournit des classes d'assistance pour ajuster les positions des axes d'un ensemble d'images au moment du dessin.

• axes_sizefournit une classe d'unités utilisées pour déterminer la taille de chaque axe. Par exemple, vous pouvez spécifier une taille fixe.

• Dividerest la classe qui calcule la position des axes. Il divise la zone rectangulaire donnée en plusieurs zones. Le diviseur est initialisé en définissant les listes de tailles horizontales et verticales sur lesquelles la division sera basée. Utilisez ensuite new_locator(), qui renvoie un objet appelable qui peut être utilisé pour définir le axes_locator des axes.

Ici, nous montrons comment réaliser la mise en page suivante : nous voulons positionner les axes dans une grille 3x4 (notez que Dividerles indices de ligne commencent à partir du bas (!) de la grille) :

+--------+--------+--------+--------+
| (2, 0) | (2, 1) | (2, 2) | (2, 3) |
+--------+--------+--------+--------+
| (1, 0) | (1, 1) | (1, 2) | (1, 3) |
+--------+--------+--------+--------+
| (0, 0) | (0, 1) | (0, 2) | (0, 3) |
+--------+--------+--------+--------+

de sorte que la rangée du bas a une hauteur fixe de 2 (pouces) et les deux rangées du haut ont un rapport de hauteur de 2 (milieu) à 3 (haut). (Par exemple, si la grille a une taille de 7 pouces, la rangée du bas sera de 2 pouces, la rangée du milieu également de 2 pouces et la rangée du haut de 3 pouces.)

Ces contraintes sont spécifiées à l'aide des classes du axes_sizemodule, à savoir :

from mpl_toolkits.axes_grid1.axes_size import Fixed, Scaled
vert = [Fixed(2), Scaled(2), Scaled(3)]

(Plus généralement, axes_sizeles classes définissent une get_size(renderer)méthode qui renvoie une paire de flottants -- une taille relative et une taille absolue. Fixed(2).get_size(renderer)retourne ; retourne .)(0, 2)Scaled(2).get_size(renderer)(2, 0)

Nous utilisons ces contraintes pour initialiser un Dividerobjet :

rect = [0.2, 0.2, 0.6, 0.6]  # Position of the grid in the figure.
vert = [Fixed(2), Scaled(2), Scaled(3)]  # As above.
horiz = [...]  # Some other horizontal constraints.
divider = Divider(fig, rect, horiz, vert)

puis utilisez Divider.new_locatorpour créer une AxesLocatorinstance pour une entrée de grille donnée :

locator = divider.new_locator(nx=0, ny=1)  # Grid entry (1, 0).

et lui confier le repérage des axes :

ax.set_axes_locator(locator)

AxesLocatorest un objet appelable qui renvoie l'emplacement et la taille de la cellule de la première colonne et de la deuxième ligne .

Des localisateurs qui s'étendent sur plusieurs cellules peuvent être créés avec, par exemple :

# Columns #0 and #1 ("0-2 range"), row #1.
locator = divider.new_locator(nx=0, nx1=2, ny=1)

Voir l'exemple,

Vous pouvez également ajuster la taille de chaque axe en fonction de ses limites de données x ou y (AxesX et AxesY).