Kurvenzeichnung mit Fehlerband

Einführung

In diesem Tutorial lernen Sie, wie Sie mit Python Matplotlib eine Kurve mit einer Fehlerbande zeichnen. Eine Fehlerbande wird verwendet, um die Unsicherheit der Kurve anzuzeigen. In diesem Beispiel nehmen wir an, dass der Fehler als Skalar err angegeben werden kann, der die Unsicherheit senkrecht zur Kurve in jedem Punkt beschreibt. Wir visualisieren diesen Fehler als eine gefärbte Bande um den Pfad mit einem .PathPatch. Der Patch wird aus zwei Pfadsegmenten (xp, yp) und (xn, yn) erstellt, die um +/- err senkrecht zur Kurve (x, y) verschoben werden.

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 öffnen.

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.

Importieren der erforderlichen Bibliotheken

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. Wir werden Matplotlib, NumPy, PathPatch und Path verwenden.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import PathPatch
from matplotlib.path import Path

Definieren der Kurve

Als nächstes definieren wir die Kurve, um die wir die Fehlerbande zeichnen möchten. In diesem Beispiel verwenden wir eine parametrisierte Kurve. Eine parametrisierte Kurve x(t), y(t) kann direkt mit ~.Axes.plot gezeichnet werden.

N = 400
t = np.linspace(0, 2 * np.pi, N)
r = 0.5 + np.cos(t)
x, y = r * np.cos(t), r * np.sin(t)

Definieren der Fehlerbande

Wir werden nun die Fehlerbande definieren, die wir um die Kurve zeichnen möchten. In diesem Beispiel nehmen wir an, dass der Fehler als Skalar err angegeben werden kann, der die Unsicherheit senkrecht zur Kurve in jedem Punkt beschreibt.

def draw_error_band(ax, x, y, err, **kwargs):
    ## Calculate normals via centered finite differences (except the first point
    ## which uses a forward difference and the last point which uses a backward
    ## difference).
    dx = np.concatenate([[x[1] - x[0]], x[2:] - x[:-2], [x[-1] - x[-2]]])
    dy = np.concatenate([[y[1] - y[0]], y[2:] - y[:-2], [y[-1] - y[-2]]])
    l = np.hypot(dx, dy)
    nx = dy / l
    ny = -dx / l

    ## end points of errors
    xp = x + nx * err
    yp = y + ny * err
    xn = x - nx * err
    yn = y - ny * err

    vertices = np.block([[xp, xn[::-1]],
                         [yp, yn[::-1]]]).T
    codes = np.full(len(vertices), Path.LINETO)
    codes[0] = codes[len(xp)] = Path.MOVETO
    path = Path(vertices, codes)
    ax.add_patch(PathPatch(path, **kwargs))

Zeichnen der Fehlerbande

Wir können nun die Fehlerbande zeichnen, indem wir die Funktion draw_error_band aufrufen und die entsprechenden Parameter übergeben.

fig, axs = plt.subplots(1, 2, layout='constrained', sharex=True, sharey=True)
errs = [
    (axs[0], "constant error", 0.05),
    (axs[1], "variable error", 0.05 * np.sin(2 * t) ** 2 + 0.04),
]
for i, (ax, title, err) in enumerate(errs):
    ax.set(title=title, aspect=1, xticks=[], yticks=[])
    ax.plot(x, y, "k")
    draw_error_band(ax, x, y, err=err,
                    facecolor=f"C{i}", edgecolor="none", alpha=.3)

plt.show()

Betrachten der Fehlerbande

Die Fehlerband sollte jetzt um die Kurve sichtbar sein.

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man mit Python Matplotlib eine Kurve mit einer Fehlerband zeichnet. Wir haben begonnen, indem wir die erforderlichen Bibliotheken importiert, die Kurve definiert, die Fehlerbande definiert, die Fehlerbande gezeichnet und die Fehlerbande betrachtet haben.