Zoom interactif dans Matplotlib | Visualisation de données

Introduction

Dans la visualisation de données, le grossissement sur une zone spécifique d'un graphique peut être extrêmement utile pour mieux comprendre et analyser les données. Matplotlib, une bibliothèque populaire de visualisation de données pour Python, fournit un moyen de créer deux panneaux identiques et de zoomer sur le panneau droit pour montrer un rectangle dans le premier panneau, représentant la région zoomée. Dans ce laboratoire, nous allons apprendre à créer cette fonction de zoom interactif dans Matplotlib.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Importez les bibliothèques nécessaires

Nous allons tout d'abord importer les bibliothèques nécessaires, y compris Matplotlib et NumPy.

import matplotlib.pyplot as plt
import numpy as np

from matplotlib.patches import Rectangle

Créez la classe UpdatingRect

Nous allons créer une sous-classe de Rectangle appelée UpdatingRect. Cette classe est appelée avec une instance Axes, ce qui fait en sorte que le rectangle mette à jour sa forme pour correspondre aux limites de l'Axes.

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

Créez la classe MandelbrotDisplay

Nous allons créer une classe appelée MandelbrotDisplay qui régénérera un ensemble fractal au fur et à mesure que nous zoomons, de sorte que nous puissions réellement voir les détails de plus en plus fins. Un carré dans le panneau gauche montrera la zone sur laquelle nous avons 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()

Créez le graphique

Nous allons créer le graphique en calculant d'abord l'image à l'aide de la classe MandelbrotDisplay, puis en créant deux panneaux identiques à l'aide de subplots. Nous ajouterons l'image à both panels à l'aide de imshow, et ajouterons l'objet UpdatingRect au panneau gauche.

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)

Ajoutez la fonctionnalité de zoom

Nous allons ajouter la fonctionnalité de zoom en connectant les événements xlim_changed et ylim_changed aux objets UpdatingRect et 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 here")

Affichez le graphique

Nous allons afficher le graphique à l'aide de la fonction show().

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à créer une fonctionnalité de zoom interactif dans Matplotlib en utilisant deux panneaux identiques et les classes UpdatingRect et MandelbrotDisplay. En ajoutant une fonctionnalité de zoom, nous pouvons mieux comprendre et analyser les données de nos graphiques.

Visualisation interactive de données avec Matplotlib