Introducción
En la visualización de datos, ampliar una área específica de una gráfica puede ser extremadamente útil para entender y analizar mejor los datos. Matplotlib, una popular biblioteca de visualización de datos para Python, proporciona una forma de crear dos paneles idénticos y ampliar el panel derecho para mostrar un rectángulo en el primer panel, que denota la región ampliada. En este laboratorio, aprenderemos cómo crear esta característica de zoom interactivo en Matplotlib.
Consejos sobre la VM
Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.
A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.
Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.
Importar las bibliotecas necesarias
Primero importaremos las bibliotecas necesarias, incluyendo Matplotlib y NumPy.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Rectangle
Crear la clase UpdatingRect
Crearemos una subclase de Rectangle llamada UpdatingRect. Esta clase se llama con una instancia de Axes, lo que hace que el rectángulo actualice su forma para que coincida con los límites del Axes.
class UpdatingRect(Rectangle):
def __call__(self, ax):
self.set_bounds(*ax.viewLim.bounds)
ax.figure.canvas.draw_idle()
Crear la clase MandelbrotDisplay
Crearemos una clase llamada MandelbrotDisplay que regenerará un conjunto fractal a medida que ampliamos, de modo que podamos ver realmente el aumento de detalles. Un cuadro en el panel izquierdo mostrará el área en la que estamos zoomed.
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()
Crear la gráfica
Crearemos la gráfica primero calculando la imagen utilizando la clase MandelbrotDisplay y luego creando dos paneles idénticos utilizando subplots. Agregaremos la imagen a ambos paneles utilizando imshow y agregaremos el objeto UpdatingRect al panel izquierdo.
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)
Agregar la funcionalidad de zoom
Agregaremos la funcionalidad de zoom conectando los eventos xlim_changed e ylim_changed a los objetos UpdatingRect y MandelbrotDisplay.
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 aquí")
Mostrar la gráfica
Mostraremos la gráfica utilizando la función show().
plt.show()
Resumen
En este laboratorio, aprendimos cómo crear una característica de zoom interactiva en Matplotlib utilizando dos paneles idénticos y las clases UpdatingRect y MandelbrotDisplay. Al agregar la funcionalidad de zoom, podemos entender y analizar mejor los datos en nuestras gráficas.