Visualização Interativa de Dados com Matplotlib

Introdução

Na visualização de dados, o zoom em uma área específica de um gráfico pode ser extremamente útil para entender e analisar melhor os dados. Matplotlib, uma biblioteca popular de visualização de dados para Python, oferece uma maneira de criar dois painéis idênticos e aplicar zoom no painel direito para mostrar um retângulo no primeiro painel, denotando a região com zoom. Neste laboratório, aprenderemos como criar este recurso interativo de zoom em Matplotlib.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.

Importar as bibliotecas necessárias

Primeiramente, importaremos as bibliotecas necessárias, incluindo Matplotlib e NumPy.

import matplotlib.pyplot as plt
import numpy as np

from matplotlib.patches import Rectangle

Criar a classe UpdatingRect

Criaremos uma subclasse de Rectangle chamada UpdatingRect. Esta classe é chamada com uma instância de Axes, fazendo com que o retângulo atualize sua forma para corresponder aos limites do Axes.

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

Criar a classe MandelbrotDisplay

Criaremos uma classe chamada MandelbrotDisplay que irá regenerar um conjunto fractal à medida que damos zoom, para que possamos realmente ver o aumento de detalhes. Uma caixa no painel esquerdo mostrará a área para a qual estamos dando zoom.

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()

Criar o gráfico

Criaremos o gráfico calculando primeiro a imagem usando a classe MandelbrotDisplay e, em seguida, criando dois painéis idênticos usando subplots. Adicionaremos a imagem a ambos os painéis usando imshow e adicionaremos o objeto UpdatingRect ao painel esquerdo.

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)

Adicionar funcionalidade de zoom

Adicionaremos a funcionalidade de zoom conectando os eventos xlim_changed e ylim_changed aos objetos UpdatingRect e 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 aqui")

Mostrar o gráfico

Mostraremos o gráfico usando a função show().

plt.show()

Resumo

Neste laboratório, aprendemos como criar uma funcionalidade de zoom interativo no Matplotlib usando dois painéis idênticos e as classes UpdatingRect e MandelbrotDisplay. Ao adicionar a funcionalidade de zoom, podemos entender e analisar melhor os dados em nossos gráficos.