Die axes_grid1-Toolkit#

Die axes_grid1 bietet folgende Funktionen:

  • Hilfsklassen (ImageGrid, RGBAxes, AxesDivider) zur Vereinfachung des Layouts von Achsen, die Bilder mit einem festen Seitenverhältnis anzeigen, während zusätzliche Einschränkungen erfüllt werden (Angleichung der Höhen einer Farbleiste und eines Bildes oder Festlegung des Abstands zwischen Bildern);

  • ParasiteAxes (twinx/twiny-ähnliche Funktionen, sodass Sie unterschiedliche Daten (z. B. unterschiedliche y-Skalen) in derselben Achse plotten können);

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

../../../_images/sphx_glr_demo_axes_grid_001.png

axes_grid1#

ImageGrid#

In Matplotlib werden Achsenposition und -größe normalerweise in normalisierten Figure-Koordinaten (0 = unten links, 1 = oben rechts) angegeben, was es schwierig macht, einen festen (absoluten) Abstand zwischen Bildern zu erreichen. ImageGrid kann verwendet werden, um einen solchen Abstand zu erreichen; siehe die Dokumentation für detaillierte API-Informationen.

../../../_images/sphx_glr_simple_axesgrid_001.png

  • Die Position jeder Achse wird zur Zeichenzeit bestimmt (siehe AxesDivider), sodass die Größe des gesamten Rasters in das gegebene Rechteck passt (wie das Seitenverhältnis der Achsen). Beachten Sie, dass in diesem Beispiel die Abstände zwischen den Achsen fest sind, auch wenn Sie die Figurengröße ändern.

  • Achsen in derselben Spalte teilen sich ihre x-Achse, und Achsen in derselben Zeile teilen sich ihre y-Achse (im Sinne von sharex, sharey). Zusätzlich haben Achsen in derselben Spalte alle die gleiche Breite, und Achsen in derselben Zeile haben alle die gleiche Höhe. Diese Breiten und Höhen werden proportional zu den Ansichtsgrenzen (xlim oder ylim) der Achsen skaliert.

    ../../../_images/sphx_glr_simple_axesgrid2_001.png

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

../../../_images/sphx_glr_demo_axes_grid_001.png

AxesDivider-Klasse#

Im Hintergrund stützen sich ImageGrid (und RGBAxes, unten beschrieben) auf AxesDivider, dessen Aufgabe es ist, die Position der Achsen zur Zeichenzeit zu berechnen.

Benutzer müssen normalerweise keine Divider direkt instanziieren, indem sie AxesDivider aufrufen; stattdessen kann make_axes_locatable verwendet werden, um einen Divider für eine Achse zu erstellen.

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

AxesDivider.append_axes kann dann verwendet werden, um eine neue Achse auf einer gegebenen Seite ("left", "right", "top", "bottom") der ursprünglichen Achse zu erstellen.

Farbleiste, deren Höhe (oder Breite) mit der Hauptachse synchronisiert ist#

../../../_images/sphx_glr_demo_colorbar_with_axes_divider_001.png

scatter_hist.py mit AxesDivider#

Das Beispiel Scatterplot mit Histogrammen kann mit make_axes_locatable neu geschrieben werden.

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.

../../../_images/sphx_glr_scatter_hist_locatable_axes_001.png

Das Beispiel Histogramm an Scatterplot anpassen mit locatable Axes unter Verwendung von AxesDivider hat einige Vorteile gegenüber dem ursprünglichen Scatterplot mit Histogrammen in Matplotlib. Zum Beispiel können Sie das Seitenverhältnis des Scatterplots festlegen, auch wenn die x- oder y-Achse entsprechend geteilt wird.

ParasiteAxes#

ParasiteAxes ist eine Achse, deren Position mit der ihrer Host-Achse identisch ist. Die Position wird zur Zeichenzeit angepasst, sodass sie auch dann funktioniert, wenn sich die Host-Achse ändert (z. B. Bilder).

In den meisten Fällen erstellen Sie zuerst eine Host-Achse, die einige Methoden zur Erstellung von Parasite-Achsen bereitstellt. Dies sind twinx, twiny (die ähnlich zu twinx und twiny in Matplotlib sind) und twin. twin verwendet eine beliebige Transformation, die zwischen den Datenkoordinaten der Host-Achse und der Parasiten-Achse abbildet. Die draw-Methode der Parasiten-Achse wird nie aufgerufen. Stattdessen sammelt die Host-Achse Künstler in der Parasiten-Achse und zeichnet sie, als ob sie zur Host-Achse gehören würden, d. h. Künstler in der Parasiten-Achse werden mit denen der Host-Achse zusammengeführt und dann gemäß ihrer zorder gezeichnet. Die Host- und Parasiten-Achsen modifizieren einige Achsenverhalten. Zum Beispiel wird der Farbzyklus für Plot-Linien zwischen Host und Parasiten geteilt. Auch der Legendenbefehl im Host erstellt eine Legende, die Linien in der Parasiten-Achse enthält. Um eine Host-Achse zu erstellen, können Sie den Befehl host_subplot oder host_axes verwenden.

Beispiel 1: twinx#

../../../_images/sphx_glr_parasite_simple_001.png

Beispiel 2: twin#

twin ohne Argument für die Transformation geht davon aus, dass die Parasiten-Achse die gleiche Datentransformation wie die Host-Achse hat. Dies kann nützlich sein, wenn Sie möchten, dass die obere (oder rechte) Achse andere Tick-Positionen, Tick-Labels oder Tick-Formatter als 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$"])
../../../_images/sphx_glr_simple_axisline4_001.png

Ein anspruchsvolleres Beispiel mit twin. Beachten Sie, dass sich, wenn Sie das x-Limit in der Host-Achse ändern, auch das x-Limit der Parasiten-Achse entsprechend ändert.

../../../_images/sphx_glr_parasite_simple2_001.png

AnchoredArtists#

axes_grid1.anchored_artists ist eine Sammlung von Künstlern, deren Position an die (Achsen-)Bbox gebunden ist, ähnlich wie Legenden. Diese Künstler leiten sich von offsetbox.OffsetBox ab, und der Künstler muss in Canvas-Koordinaten gezeichnet werden. Es gibt eine eingeschränkte Unterstützung für beliebige Transformationen. Zum Beispiel wird die Ellipse im folgenden Beispiel eine Breite und Höhe in Datenkoordinaten haben.

../../../_images/sphx_glr_simple_anchored_artists_001.png

InsetLocator#

Siehe auch

Axes.inset_axes und Axes.indicate_inset_zoom in der Hauptbibliothek.

axes_grid1.inset_locator bietet Hilfsklassen und Funktionen zur Platzierung von Inset-Achsen an einer verankerten Position der Elternachse, ähnlich wie bei AnchoredArtist.

inset_locator.inset_axes erstellt eine Inset-Achse, deren Größe entweder fest ist oder ein fester Anteil der Elternachse ist.

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

erstellt eine Inset-Achse, deren Breite 30 % der Elternachse beträgt und deren Höhe fest auf 1 Zoll eingestellt ist.

inset_locator.zoomed_inset_axes erstellt eine Inset-Achse, deren Datenskala die der Elternachse multipliziert mit einem Faktor ist, z. B.

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

erstellt eine Inset-Achse, deren Datenskala die Hälfte der Elternachse beträgt. Dies kann nützlich sein, um den gezoomten Bereich auf der Elternachse zu markieren.

../../../_images/sphx_glr_inset_locator_demo_001.png

inset_locator.mark_inset ermöglicht die Markierung der Position des Bereichs, der von der Inset-Achse dargestellt wird.

../../../_images/sphx_glr_inset_locator_demo2_001.png

RGBAxes#

RGBAxes ist eine Hilfsklasse zur bequemen Anzeige von RGB-Composite-Bildern. Wie ImageGrid werden die Achsenpositionen so angepasst, dass der von ihnen eingenommene Bereich in ein gegebenes Rechteck passt. Außerdem sind die x-Achse und die y-Achse jeder Achse geteilt.

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)
../../../_images/sphx_glr_demo_axes_rgb_001.png

AxesDivider#

Das Modul mpl_toolkits.axes_grid1.axes_divider bietet Hilfsklassen zur Anpassung der Achsenpositionen einer Reihe von Bildern zur Zeichenzeit.

  • axes_size bietet eine Klasse von Einheiten, die zur Bestimmung der Größe jeder Achse verwendet werden. Sie können beispielsweise eine feste Größe angeben.

  • Divider ist die Klasse, die die Achsenposition berechnet. Sie teilt den gegebenen rechteckigen Bereich in mehrere Bereiche auf. Der Divider wird initialisiert, indem die Listen der horizontalen und vertikalen Größen festgelegt werden, auf denen die Teilung basiert. Verwenden Sie dann new_locator(), die ein aufrufbares Objekt zurückgibt, das verwendet werden kann, um den axes_locator der Achse festzulegen.

Hier demonstrieren wir, wie das folgende Layout erreicht werden kann: Wir möchten Achsen in einem 3x4-Raster positionieren (beachten Sie, dass die Zeilenindizes bei Divider am *unteren* (!) Ende 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) │
└────────┴────────┴────────┴────────┘

sodass die unterste Zeile eine feste Höhe von 2 (Zoll) hat und die oberen beiden Zeilen ein Höhenverhältnis von 2 (mittlere) zu 3 (obere) haben. (Wenn das Raster beispielsweise eine Größe von 7 Zoll hat, ist die unterste Zeile 2 Zoll, die mittlere Zeile ebenfalls 2 Zoll und die oberste Zeile 3 Zoll.)

Diese Einschränkungen werden unter Verwendung von Klassen aus dem Modul axes_size spezifiziert, nämlich

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

(Allgemeiner gesagt definieren axes_size-Klassen eine get_size(renderer)-Methode, die ein Paar von Fließkommazahlen zurückgibt - eine relative Größe und eine absolute Größe. Fixed(2).get_size(renderer) gibt (0, 2) zurück; Scaled(2).get_size(renderer) gibt (2, 0) zurück.)

Wir verwenden diese Einschränkungen, um ein Divider-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)

dann Divider.new_locator verwenden, um einen aufrufbaren Achsen-Locator für einen gegebenen Gittereintrag zu erstellen.

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

und diesen für die Lokalisierung der Achsen zuständig machen.

ax.set_axes_locator(locator)

Der aufrufbare Achsen-Locator gibt die Position und Größe der Zelle in der ersten Spalte und der zweiten Zeile zurück.

Locator, die über mehrere Zellen gehen, können mit z. B. erstellt werden.

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

Siehe das Beispiel,

../../../_images/sphx_glr_simple_axes_divider1_001.png

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

../../../_images/sphx_glr_simple_axes_divider3_001.png
Auf dieser Seite