Autoscaling Achse

Die Grenzen einer Achse können manuell gesetzt werden (z.B. ax.set_xlim(xmin, xmax)) oder Matplotlib kann sie automatisch basierend auf den bereits auf den Achsen vorhandenen Daten setzen. Es gibt eine Reihe von Optionen für dieses Autoscaling-Verhalten, die unten erläutert werden.

Wir beginnen mit einem einfachen Liniendiagramm, das zeigt, dass das Autoscaling die Achsenlimits um 5 % über die Datenlimits hinaus erweitert (-2π, 2π).

import matplotlib.pyplot as plt
import numpy as np

import matplotlib as mpl

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

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

Ränder

Der Standardrand um die Datenlimits beträgt 5 %, was auf den Standardkonfigurationseinstellungen von rcParams["axes.xmargin"] (Standard: 0.05), rcParams["axes.ymargin"] (Standard: 0.05) und rcParams["axes.zmargin"] (Standard: 0.05) basiert.

print(ax.margins())

(0.05, 0.05)

Die Randgröße kann überschrieben werden, um sie kleiner oder größer zu machen, indem margins verwendet wird.

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

Im Allgemeinen können Ränder im Bereich (-0.5, ∞) liegen, wobei negative Ränder die Achsenlimits auf einen Teilbereich des Datenbereichs setzen, d.h. sie schneiden Daten ab. Die Verwendung einer einzelnen Zahl für Ränder beeinflusst beide Achsen, ein einzelner Rand kann mit den Schlüsselwortargumenten x oder y angepasst werden, aber die positionelle und die Schlüsselwortschnittstelle können nicht kombiniert werden.

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

Anhaftende Kanten

Es gibt Plot-Elemente (Artist), die normalerweise ohne Ränder verwendet werden. Zum Beispiel werden Falschfarbenbilder (z.B. erstellt mit Axes.imshow) nicht in die Randberechnung einbezogen.

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

Diese Überschreibung von Rändern wird durch "anhaftende Kanten" bestimmt, eine Eigenschaft der Artist-Klasse, die das Hinzufügen von Rändern zu Achsenlimits unterdrücken kann. Die Auswirkung von anhaftenden Kanten kann auf einer Achse deaktiviert werden, indem use_sticky_edges geändert wird. Künstler haben eine Eigenschaft Artist.sticky_edges, und die Werte der anhaftenden Kanten können durch Schreiben in Artist.sticky_edges.x oder Artist.sticky_edges.y geändert werden.

Das folgende Beispiel zeigt, wie die Überschreibung funktioniert und wann sie benötigt wird.

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

Wir können sehen, dass durch Setzen von use_sticky_edges auf False das Bild mit den angeforderten Rändern gerendert wird.

Während anhaftende Kanten die Achsenlimits durch zusätzliche Ränder nicht erhöhen, werden negative Ränder weiterhin berücksichtigt. Dies ist in den reduzierten Limits des dritten Bildes ersichtlich.

Autoscaling steuern

Standardmäßig werden die Limits jedes Mal neu berechnet, wenn Sie eine neue Kurve zum Plot hinzufügen.

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

Es gibt jedoch Fälle, in denen Sie die Ansicht nicht automatisch an neue Daten anpassen möchten.

Eine Möglichkeit, das Autoscaling zu deaktivieren, ist das manuelle Setzen des Achsenlimits. Nehmen wir an, wir möchten nur einen Teil der Daten detaillierter sehen. Das Setzen von xlim bleibt bestehen, auch wenn wir weitere Kurven zu den Daten hinzufügen. Um die neuen Limits neu zu berechnen, löst das Aufrufen von Axes.autoscale die Funktionalität manuell aus.

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()")

Wir können überprüfen, ob das erste Diagramm das Autoscaling deaktiviert hat und das zweite Diagramm es wieder aktiviert hat, indem wir Axes.get_autoscale_on() verwenden.

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

False
True

Die Argumente der Funktion autoscale geben uns präzise Kontrolle über den Autoscaling-Prozess. Eine Kombination der Argumente enable und axis setzt die Autoscaling-Funktion für die ausgewählte Achse (oder beide). Das Argument tight setzt den Rand der ausgewählten Achse auf Null. Um die Einstellungen von entweder enable oder tight beizubehalten, können Sie das Gegenteil auf None setzen, so dass es nicht geändert wird. Das Setzen von enable auf None und tight auf True beeinflusst jedoch beide Achsen unabhängig vom Argument axis.

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)

Arbeiten mit Sammlungen

Autoscaling funktioniert ohne zusätzlichen Aufwand für alle Linien, Patches und Bilder, die der Achse hinzugefügt werden. Einer der Künstler, mit denen es nicht funktioniert, ist eine Collection. Nach dem Hinzufügen einer Sammlung zur Achse muss autoscale_view() manuell aufgerufen werden, um die Achsenlimits neu zu berechnen.

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