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.