Mise à l'échelle automatique

Les limites sur un axe peuvent être définies manuellement (par exemple ) ou Matplotlib peut les définir automatiquement en fonction des données déjà sur les axes. Il existe un certain nombre d'options pour ce comportement de mise à l'échelle automatique, décrites ci-dessous.ax.set_xlim(xmin, xmax)

Nous commencerons par un simple graphique linéaire montrant que la mise à l'échelle automatique étend les limites de l'axe de 5 % au-delà des limites des données (-2π, 2π).

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sinc(x)

fig, ax = plt.subplots()
ax.plot(x, y)

[<matplotlib.lines.Line2D object at 0x7f2cde5343a0>]

Marges

La marge par défaut autour des limites de données est de 5 % :

ax.margins()

(0.05, 0.05)

Les marges peuvent être agrandies en utilisant margins:

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)

En général, les marges peuvent être dans la plage (-0,5, ∞), où les marges négatives fixent les limites des axes à une sous-plage de la plage de données, c'est-à-dire qu'elles découpent les données. L'utilisation d'un seul numéro pour les marges affecte les deux axes, une seule marge peut être personnalisée à l'aide d'arguments de mots -clés xou y, mais l'interface de position et de mots-clés ne peut pas être combinée.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(y=-0.2)

Bords collants

Il existe des éléments de tracé ( Artists) qui sont généralement utilisés sans marges. Par exemple, les images en fausses couleurs (par exemple créées avec Axes.imshow) ne sont pas prises en compte dans le calcul des marges.

xx, yy = np.meshgrid(x, x)
zz = np.sinc(np.sqrt((xx - 1)**2 + (yy - 1)**2))

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].imshow(zz)
ax[0].set_title("default margins")
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].set_title("margins(0.2)")

Text(0.5, 1.0, 'margins(0.2)')

Ce remplacement des marges est déterminé par les "bords collants", une propriété de Artistla classe qui peut supprimer l'ajout de marges aux limites des axes. L'effet des bords collants peut être désactivé sur un Axe en modifiant use_sticky_edges. Les artistes ont une propriété Artist.sticky_edgeset les valeurs des bords collants peuvent être modifiées en écrivant dans Artist.sticky_edges.xou Artist.sticky_edges.y.

L'exemple suivant montre comment fonctionne le remplacement et quand il est nécessaire.

fig, ax = plt.subplots(ncols=3, figsize=(16, 10))
ax[0].imshow(zz)
ax[0].margins(0.2)
ax[0].set_title("default use_sticky_edges\nmargins(0.2)")
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].use_sticky_edges = False
ax[1].set_title("use_sticky_edges=False\nmargins(0.2)")
ax[2].imshow(zz)
ax[2].margins(-0.2)
ax[2].set_title("default use_sticky_edges\nmargins(-0.2)")

Text(0.5, 1.0, 'default use_sticky_edges\nmargins(-0.2)')

Nous pouvons voir que le réglage use_sticky_edgessur False rend l'image avec les marges demandées.

Bien que les bords collants n'augmentent pas les limites de l'axe grâce à des marges supplémentaires, les marges négatives sont toujours prises en compte. Cela se voit dans les limites réduites de la troisième image.

Contrôler la mise à l'échelle automatique

Par défaut, les limites sont recalculées chaque fois que vous ajoutez une nouvelle courbe au tracé :

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_title("Single curve")
ax[1].plot(x, y)
ax[1].plot(x * 2.0, y)
ax[1].set_title("Two curves")

Text(0.5, 1.0, 'Two curves')

Cependant, dans certains cas, vous ne souhaitez pas ajuster automatiquement la fenêtre d'affichage aux nouvelles données.

Une façon de désactiver la mise à l'échelle automatique consiste à définir manuellement la limite d'axe. Disons que nous voulons voir seulement une partie des données plus en détail. Le réglage xlimpersiste même si nous ajoutons plus de courbes aux données. Pour recalculer les nouvelles limites, l'appel Axes.autoscalebasculera la fonctionnalité manuellement.

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_xlim(left=-1, right=1)
ax[0].plot(x + np.pi * 0.5, y)
ax[0].set_title("set_xlim(left=-1, right=1)\n")
ax[1].plot(x, y)
ax[1].set_xlim(left=-1, right=1)
ax[1].plot(x + np.pi * 0.5, y)
ax[1].autoscale()
ax[1].set_title("set_xlim(left=-1, right=1)\nautoscale()")

Text(0.5, 1.0, 'set_xlim(left=-1, right=1)\nautoscale()')

Nous pouvons vérifier que la première parcelle a une mise à l'échelle automatique désactivée et que la seconde parcelle l'a à nouveau activée en utilisant Axes.get_autoscale_on():

print(ax[0].get_autoscale_on())  # False means disabled
print(ax[1].get_autoscale_on())  # True means enabled -> recalculated

False
True

Les arguments de la fonction de mise à l'échelle automatique nous donnent un contrôle précis sur le processus de mise à l'échelle automatique. Une combinaison d'arguments enableet axisdéfinit la fonction de mise à l'échelle automatique pour l'axe sélectionné (ou les deux). L'argument tight définit la marge de l'axe sélectionné sur zéro. Pour conserver les paramètres de l'un enableou l'autre, tightvous pouvez définir l'opposé sur None , de cette façon, il ne doit pas être modifié. Cependant, définir enablesur None et tight sur True affecte les deux axes quel que soit l' axisargument.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)
ax.autoscale(enable=None, axis="x", tight=True)

print(ax.margins())

(0, 0)

Travailler avec des collections

La mise à l'échelle automatique fonctionne immédiatement pour toutes les lignes, patchs et images ajoutés aux axes. L'un des artistes avec qui cela ne fonctionnera pas est un Collection. Après avoir ajouté une collection aux axes, il faut déclencher manuellement le autoscale_view()pour recalculer les limites des axes.

fig, ax = plt.subplots()
collection = mpl.collections.StarPolygonCollection(
    5, rotation=0, sizes=(250,),  # five point star, zero angle, size 250px
    offsets=np.column_stack([x, y]),  # Set the positions
    offset_transform=ax.transData,  # Propagate transformations of the Axes
)
ax.add_collection(collection)
ax.autoscale_view()