Visualización de datos interactiva con Matplotlib

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.