Interaktive Datenvisualisierung mit Matplotlib

Einführung

Beim Datenvisualisierung kann das Einzoomen auf einen bestimmten Bereich eines Diagramms sehr nützlich sein, um die Daten besser zu verstehen und zu analysieren. Matplotlib, eine beliebte Datenvisualisierungsbibliothek für Python, bietet eine Möglichkeit, zwei identische Panels zu erstellen und im rechten Panel einzuzoomen, um ein Rechteck im ersten Panel anzuzeigen, das die eingezogene Region darstellt. In diesem Lab werden wir lernen, wie wir diese interaktive Einzoomfunktion in Matplotlib erstellen.

VM-Tipps

Nachdem der VM-Start abgeschlossen 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.

Importieren von erforderlichen Bibliotheken

Wir importieren zunächst die erforderlichen Bibliotheken, einschließlich Matplotlib und NumPy.

import matplotlib.pyplot as plt
import numpy as np

from matplotlib.patches import Rectangle

Erstellen der Klasse UpdatingRect

Wir werden eine Unterklasse von Rectangle namens UpdatingRect erstellen. Diese Klasse wird mit einer Axes-Instanz aufgerufen, was dazu führt, dass das Rechteck seine Form aktualisiert, um den Grenzen der Axes zu entsprechen.

class UpdatingRect(Rectangle):
    def __call__(self, ax):
        self.set_bounds(*ax.viewLim.bounds)
        ax.figure.canvas.draw_idle()

Erstellen der Klasse MandelbrotDisplay

Wir werden eine Klasse namens MandelbrotDisplay erstellen, die einen Fraktalsatz beim Einzoomen regeneriert, sodass wir tatsächlich die zunehmende Detailsichtbarkeit sehen können. Ein Rechteck im linken Panel zeigt den Bereich, auf den wir eingezogen haben.

class MandelbrotDisplay:
    def __init__(self, h=500, w=500, niter=50, radius=2., power=2):
        self.height = h
        self.width = w
        self.niter = niter
        self.radius = radius
        self.power = power

    def compute_image(self, xstart, xend, ystart, yend):
        self.x = np.linspace(xstart, xend, self.width)
        self.y = np.linspace(ystart, yend, self.height).reshape(-1, 1)
        c = self.x + 1.0j * self.y
        threshold_time = np.zeros((self.height, self.width))
        z = np.zeros(threshold_time.shape, dtype=complex)
        mask = np.ones(threshold_time.shape, dtype=bool)
        for i in range(self.niter):
            z[mask] = z[mask]**self.power + c[mask]
            mask = (np.abs(z) < self.radius)
            threshold_time += mask
        return threshold_time

    def ax_update(self, ax):
        ax.set_autoscale_on(False)
        self.width, self.height = \
            np.round(ax.patch.get_window_extent().size).astype(int)
        vl = ax.viewLim
        extent = vl.x0, vl.x1, vl.y0, vl.y1
        im = ax.images[-1]
        im.set_data(self.compute_image(*extent))
        im.set_extent(extent)
        ax.figure.canvas.draw_idle()

Erstellen des Diagramms

Wir werden das Diagramm erstellen, indem wir zuerst das Bild mithilfe der MandelbrotDisplay-Klasse berechnen und dann zwei identische Panels mit Hilfe von subplots erstellen. Wir werden das Bild zu beiden Panels mit imshow hinzufügen und das UpdatingRect-Objekt zum linken Panel hinzufügen.

md = MandelbrotDisplay()
Z = md.compute_image(-2., 0.5, -1.25, 1.25)

fig1, (ax1, ax2) = plt.subplots(1, 2)
ax1.imshow(Z, origin='lower',
           extent=(md.x.min(), md.x.max(), md.y.min(), md.y.max()))
ax2.imshow(Z, origin='lower',
           extent=(md.x.min(), md.x.max(), md.y.min(), md.y.max()))

rect = UpdatingRect(
    [0, 0], 0, 0, facecolor='none', edgecolor='black', linewidth=1.0)
rect.set_bounds(*ax2.viewLim.bounds)
ax1.add_patch(rect)

Hinzufügen der Zoomefunktionalität

Wir werden die Zoomefunktionalität hinzufügen, indem wir die xlim_changed- und ylim_changed-Ereignisse an die UpdatingRect- und MandelbrotDisplay-Objekte anbinden.

ax2.callbacks.connect('xlim_changed', rect)
ax2.callbacks.connect('ylim_changed', rect)

ax2.callbacks.connect('xlim_changed', md.ax_update)
ax2.callbacks.connect('ylim_changed', md.ax_update)
ax2.set_title("Zoom hier")

Zeige das Diagramm an

Wir werden das Diagramm mit der show()-Funktion anzeigen.

plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Matplotlib eine interaktive Zoomefunktion mit Hilfe von zwei identischen Panels sowie der UpdatingRect- und MandelbrotDisplay-Klassen erstellt. Indem wir die Zoomefunktionalität hinzufügen, können wir die Daten in unseren Diagrammen besser verstehen und analysieren.