Übersicht über mpl_toolkits.axes_grid1

axes_grid1bietet die folgenden Funktionen:

• Hilfsklassen ( ImageGrid , RGBAxes , AxesDivider ) zum Vereinfachen des Layouts von Achsen, die Bilder mit einem festen Seitenverhältnis anzeigen, während zusätzliche Einschränkungen erfüllt werden (Anpassen der Höhen eines Farbbalkens und eines Bildes oder Korrigieren des Abstands zwischen Bildern);

• ParasiteAxes (twinx/twiny-ähnliche Merkmale, damit Sie unterschiedliche Daten (z. B. unterschiedliche y-Skalen) in denselben Achsen darstellen können);

• AnchoredArtists (benutzerdefinierte Künstler, die ähnlich wie Legenden an einer verankerten Position platziert werden).

Achsen_Gitter1

ImageGrid

In Matplotlib werden Achsenposition und -größe normalerweise in normalisierten Figurenkoordinaten (0 = unten links, 1 = oben rechts) angegeben, was es schwierig macht, eine feste (absolute) Auffüllung zwischen Bildern zu erreichen. ImageGridkann verwendet werden, um eine solche Polsterung zu erreichen; Ausführliche API-Informationen finden Sie in der Dokumentation.

• Die Position der einzelnen Achsen wird zum Zeitpunkt des Zeichnens festgelegt (siehe AxesDivider ), damit die Größe des gesamten Gitters in das vorgegebene Rechteck passt (wie das Aussehen von Achsen). Beachten Sie, dass in diesem Beispiel die Polsterungen zwischen den Achsen fixiert sind, auch wenn Sie die Abbildungsgröße ändern.

• Achsen in derselben Spalte teilen ihre x-Achse und Achsen in derselben Zeile teilen ihre y-Achse (im Sinne von sharex, sharey). Außerdem haben Achsen in derselben Spalte alle dieselbe Breite und Achsen in derselben Zeile haben alle dieselbe Höhe. Diese Breiten und Höhen werden proportional zu den Sichtgrenzen der Achsen (xlim oder ylim) skaliert.

  

Die folgenden Beispiele zeigen, was Sie mit ImageGrid machen können.

AxesDivider Klasse

Hinter den Kulissen verlassen sich ImageGrid (und RGBAxes, unten beschrieben) auf AxesDivider, dessen Aufgabe darin besteht, die Position der Achsen zum Zeitpunkt des Zeichnens zu berechnen.

Benutzer müssen Teiler normalerweise nicht direkt instanziieren, indem sie AxesDivider; kann stattdessen make_axes_locatableverwendet werden, um einen Teiler für eine Achse zu erstellen:

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

AxesDivider.append_axeskann dann verwendet werden, um eine neue Achse auf einer bestimmten Seite ("links", "rechts", "oben", "unten") der ursprünglichen Achsen zu erstellen.

Farbbalken, dessen Höhe (oder Breite) mit den Hauptachsen synchronisiert ist

scatter_hist.py mit AxesDivider

Das Streudiagramm mit Histogrammen Beispiel kann neu geschrieben werden mit 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')

Siehe den vollständigen Quellcode unten.

Das Streuhistogramm (lokalisierbare Achsen) mit dem AxesDivider hat einige Vorteile gegenüber dem ursprünglichen Streudiagramm mit Histogrammen in Matplotlib. Beispielsweise können Sie das Seitenverhältnis des Scatterplots einstellen, auch wenn die x-Achse oder y-Achse entsprechend geteilt wird.

Parasite Axes

Die ParasiteAxes ist eine Axt, deren Position mit der ihrer Wirtsachsen identisch ist. Der Standort wird in der Ziehzeit angepasst, somit funktioniert es auch wenn der Host seinen Standort ändert (zB Bilder).

In den meisten Fällen erstellen Sie zuerst eine Wirtsachse, die einige Methoden bereitstellt, die zum Erstellen von Parasitenachsen verwendet werden können. Sie sind twinx, twiny(die ähnlich wie twinxund twinyin matplotlib sind) und twin. twinnimmt eine willkürliche Transformation, die zwischen den Datenkoordinaten der Hostachsen und der Parasitenachsen abbildet. Dasdraw Methode der Parasitenäxte werden nie genannt. Stattdessen sammelt Host-Axt Künstler in Parasiten-Äxten und zeichnet sie, als ob sie zu den Host-Äxten gehören würden, dh Künstler in Parasiten-Äxten werden mit denen der Host-Achsen zusammengeführt und dann gemäß ihrer Zorder gezeichnet. Die Wirts- und Parasitenachsen modifizieren einiges des Achsenverhaltens. Beispielsweise wird der Farbzyklus für Plotlinien zwischen Wirt und Parasiten geteilt. Außerdem erstellt der Befehl legend in host eine Legende, die Linien in den Parasitenachsen enthält. Um eine Host-Achse zu erstellen, können Sie den Befehl host_subplotoder verwenden.host_axes

Beispiel 1. twinx

Beispiel 2. Zwilling

twinohne Transformationsargument geht davon aus, dass die Parasitenachsen dieselbe Datentransformation wie der Host haben. Dies kann nützlich sein, wenn Sie möchten, dass die obere (oder rechte) Achse unterschiedliche Tick-Positionen, Tick-Labels oder Tick-Formatierer für die untere (oder linke) Achse hat.

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

Ein anspruchsvolleres Beispiel mit twin. Beachten Sie, dass sich die x-Grenze der parasitären Achsen entsprechend ändern, wenn Sie die x-Grenze in den Host-Achsen ändern.

AnchoredArtists

axes_grid1.anchored_artistsist eine Sammlung von Künstlern, deren Standort mit der (Achsen-)Bbox verankert ist, ähnlich wie Legenden. Diese Künstler stammen von offsetbox.OffsetBox, und der Künstler muss in Leinwandkoordinaten gezeichnet werden. Beliebige Transformationen werden nur eingeschränkt unterstützt. Beispielsweise hat die Ellipse im Beispiel unten Breite und Höhe in Datenkoordinaten.

InsetLocator

Siehe auch

Axes.inset_axesund Axes.indicate_inset_zoomin der Hauptbibliothek.

axes_grid1.inset_locatorstellt Hilfsklassen und -funktionen bereit, um Einschubachsen an einer verankerten Position der übergeordneten Achsen zu platzieren, ähnlich wie AnchoredArtist.

inset_locator.inset_axeserstellt eine Einfügungsachse, deren Größe entweder fest oder ein fester Anteil der Elternachsen ist:

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

erstellt eine Einschubachse, deren Breite 30 % der Elternachsen beträgt und deren Höhe auf 1 Zoll festgelegt ist.

inset_locator.zoomed_inset_axeserstellt eine eingefügte Achse, deren Datenmaßstab der der Elternachsen multipliziert mit einem Faktor ist, z

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

erstellt eine eingefügte Achse, deren Datenmaßstab die Hälfte der übergeordneten Achsen beträgt. Dies kann nützlich sein, um den gezoomten Bereich auf den übergeordneten Achsen zu markieren:

inset_locator.mark_insetermöglicht das Markieren der Position des Bereichs, der durch die eingefügten Achsen dargestellt wird:

RGBAchsen

RGBAxes ist eine Hilfsklasse zum bequemen Anzeigen von zusammengesetzten RGB-Bildern. Wie bei ImageGrid wird die Position der Achsen so angepasst, dass der von ihnen eingenommene Bereich in ein bestimmtes Rechteck passt. Außerdem werden die x-Achse und die y-Achse jeder Achse gemeinsam genutzt.

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)

AxesDivider

Das mpl_toolkits.axes_grid1.axes_dividerModul stellt Hilfsklassen bereit, um die Achsenpositionen einer Reihe von Bildern zur Zeichenzeit anzupassen.

• axes_sizestellt eine Klasse von Einheiten bereit, die verwendet werden, um die Größe jeder Achse zu bestimmen. Sie können beispielsweise eine feste Größe angeben.

• Dividerist die Klasse, die die Achsenposition berechnet. Es teilt den gegebenen rechteckigen Bereich in mehrere Bereiche. Der Teiler wird initialisiert, indem die Listen der horizontalen und vertikalen Größen eingestellt werden, auf denen die Teilung basiert. Verwenden Sie dann new_locator(), das ein aufrufbares Objekt zurückgibt, mit dem der axis_locator der Achsen festgelegt werden kann.

Hier demonstrieren wir, wie Sie das folgende Layout erreichen: Wir möchten Achsen in einem 3x4-Raster positionieren (beachten Sie, dass Dividerdie Zeilenindizes am unteren Rand (!) des Rasters beginnen):

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

so dass die untere Reihe eine feste Höhe von 2 (Zoll) hat und die oberen zwei Reihen ein Höhenverhältnis von 2 (Mitte) zu 3 (oben) haben. (Wenn das Gitter beispielsweise eine Größe von 7 Zoll hat, ist die untere Reihe 2 Zoll, die mittlere Reihe ebenfalls 2 Zoll und die obere Reihe 3 Zoll.)

Diese Einschränkungen werden mithilfe von Klassen aus dem axes_sizeModul angegeben, nämlich:

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

(Ganz allgemein axes_sizedefinieren Klassen eine Methode, die ein Paar Floats zurückgibt – get_size(renderer)eine relative Größe und eine absolute Größe .Fixed(2).get_size(renderer)(0, 2)Scaled(2).get_size(renderer)(2, 0)

DividerWir verwenden diese Einschränkungen, um ein Objekt zu initialisieren :

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)

Verwenden Sie dann Divider.new_locator, um eine AxesLocatorInstanz für einen bestimmten Rastereintrag zu erstellen:

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

und machen Sie es für die Lokalisierung der Achsen verantwortlich:

ax.set_axes_locator(locator)

Das AxesLocatorist ein aufrufbares Objekt, das die Position und Größe der Zelle in der ersten Spalte und der zweiten Zeile zurückgibt.

Locators, die sich über mehrere Zellen erstrecken, können z. B. erstellt werden mit:

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

Siehe das Beispiel,

Sie können auch die Größe jeder Achse entsprechend ihrer x- oder y-Datengrenzen (AxesX und AxesY) anpassen.