Matplotlib 2D-Bilddarstellung mit pcolormesh

Einführung

In diesem Tutorial lernen wir, wie wir die pcolormesh-Funktion in der Matplotlib-Bibliothek verwenden, um 2D-Bildplots zu generieren. Wir werden die grundlegende Verwendung von pcolormesh, nicht-rectilineare pcolormesh, zentrierte Koordinaten und das Erstellen von Ebenen mit Norms behandeln.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Grundlegende pcolormesh

Wir definieren normalerweise eine pcolormesh, indem wir den Rand von Vierecken und den Wert des Vierecks definieren. Beachten Sie, dass hier x und y jeweils ein zusätzliches Element im jeweiligen Dimension haben als Z.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(19680801)
Z = np.random.rand(6, 10)
x = np.arange(-0.5, 10, 1)  ## Länge = 11
y = np.arange(4.5, 11, 1)  ## Länge = 7

fig, ax = plt.subplots()
ax.pcolormesh(x, y, Z)

Nicht-rectilineare pcolormesh

Beachten Sie, dass wir auch Matrizen für X und Y angeben können und nicht-rectilineare Vierecke haben.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(19680801)
Z = np.random.rand(6, 10)
x = np.arange(-0.5, 10, 1)  ## Länge = 11
y = np.arange(4.5, 11, 1)  ## Länge = 7
X, Y = np.meshgrid(x, y)
X = X + 0.2 * Y  ## Neigen Sie die Koordinaten.
Y = Y + 0.3 * X

fig, ax = plt.subplots()
ax.pcolormesh(X, Y, Z)

Zentrierte Koordinaten

Oft möchte ein Benutzer X und Y mit der gleichen Größe wie Z an .axes.Axes.pcolormesh übergeben. Dies ist auch möglich, wenn shading='auto' übergeben wird (Standardwert, der von :rc:pcolor.shading gesetzt wird). Vor Matplotlib 3.3 hätte shading='flat' die letzte Spalte und Zeile von Z weggelassen, aber jetzt wird ein Fehler ausgegeben. Wenn das wirklich das ist, was Sie möchten, können Sie einfach die letzte Zeile und Spalte von Z manuell weglassen:

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(19680801)
Z = np.random.rand(6, 10)
x = np.arange(10)  ## Länge = 10
y = np.arange(6)  ## Länge = 6
X, Y = np.meshgrid(x, y)

fig, axs = plt.subplots(2, 1, sharex=True, sharey=True)
axs[0].pcolormesh(X, Y, Z, vmin=np.min(Z), vmax=np.max(Z), shading='auto')
axs[0].set_title("shading='auto' = 'nearest'")
axs[1].pcolormesh(X, Y, Z[:-1, :-1], vmin=np.min(Z), vmax=np.max(Z),
                  shading='flat')
axs[1].set_title("shading='flat'")

Erstellen von Ebenen mit Norms

Zeigt, wie Normalisierung und Colormap-Instanzen kombiniert werden, um "Ebenen" in .axes.Axes.pcolor, .axes.Axes.pcolormesh und .axes.Axes.imshow-Typen von Plots zu zeichnen, ähnlich wie das levels-Schlüsselwortargument für contour/contourf.

import matplotlib.pyplot as plt
import numpy as np

from matplotlib.colors import BoundaryNorm
from matplotlib.ticker import MaxNLocator

## Verkleinern Sie diese Werte, um die Auflösung zu erhöhen
dx, dy = 0.05, 0.05

## Generieren Sie 2 2D-Gitter für die x- und y-Grenzen
y, x = np.mgrid[slice(1, 5 + dy, dy),
                slice(1, 5 + dx, dx)]

z = np.sin(x)**10 + np.cos(10 + y*x) * np.cos(x)

## x und y sind die Grenzen, daher sollte z der Wert *innerhalb* dieser Grenzen sein.
## Entfernen Sie daher den letzten Wert aus dem z-Array.
z = z[:-1, :-1]
levels = MaxNLocator(nbins=15).tick_values(z.min(), z.max())


## Wählen Sie die gewünschte Farbpalette, sinnvolle Ebenen und definieren Sie eine Normalisierungsinstanz,
## die Datenwerte annimmt und diese in Ebenen umwandelt.
cmap = plt.colormaps['PiYG']
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)

fig, (ax0, ax1) = plt.subplots(nrows=2)

im = ax0.pcolormesh(x, y, z, cmap=cmap, norm=norm)
fig.colorbar(im, ax=ax0)
ax0.set_title('pcolormesh mit Ebenen')


## Konturlinien sind *punktbasiertes* Plots, daher konvertieren wir unsere Grenze in Punktzentren
cf = ax1.contourf(x[:-1, :-1] + dx/2.,
                  y[:-1, :-1] + dy/2., z, levels=levels,
                  cmap=cmap)
fig.colorbar(cf, ax=ax1)
ax1.set_title('contourf mit Ebenen')

## Anpassen Sie den Abstand zwischen den Teilplots, damit der Titel von `ax1` und die Strichmarkenbeschriftungen von `ax0`
## nicht überlappen
fig.tight_layout()

plt.show()

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie die pcolormesh-Funktion in der Matplotlib-Bibliothek verwendet wird. Wir haben die Grundlagen der pcolormesh-Verwendung, die nicht-rectilineare pcolormesh, die zentrierten Koordinaten und das Erstellen von Ebenen mit Norms behandelt. Diese Techniken können verwendet werden, um verschiedene Arten von 2D-Bildplots in Matplotlib zu generieren.