Sélectionner des indices à l'aide du Sélecteur de polygones

Introduction

Ce laboratoire montre comment utiliser l'outil Sélecteur de polygones dans Matplotlib pour sélectionner des indices à partir d'une collection. L'outil Sélecteur de polygones permet à l'utilisateur de sélectionner des points sur un graphique en traçant un polygone autour d'eux. Les points sélectionnés sont ensuite mis en évidence tandis que les points non sélectionnés sont assombris. Les indices des points sélectionnés sont enregistrés dans un tableau, qui peut ensuite être utilisé pour une analyse plus approfondie.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet 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ésoudrons rapidement le problème pour vous.

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires pour ce laboratoire. Nous utiliserons numpy et matplotlib pour la manipulation et la visualisation des données.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.path import Path
from matplotlib.widgets import PolygonSelector

Création de données

Dans cette étape, nous allons créer quelques données à visualiser. Nous allons créer un nuage de points sur une grille.

fig, ax = plt.subplots()
grid_size = 5
grid_x = np.tile(np.arange(grid_size), grid_size)
grid_y = np.repeat(np.arange(grid_size), grid_size)
pts = ax.scatter(grid_x, grid_y)

Définition de la classe Sélecteur

Dans cette étape, nous allons définir une classe qui nous permettra de sélectionner des points dans le nuage de points à l'aide de l'outil Sélecteur de polygones. Cette classe enregistrera les indices des points sélectionnés dans un tableau.

class SelectFromCollection:
    """
    Sélectionner des indices à partir d'une collection Matplotlib à l'aide de `PolygonSelector`.

    Les indices sélectionnés sont enregistrés dans l'attribut `ind`. Cet outil assombrit les
    points qui ne font pas partie de la sélection (c'est-à-dire réduit leurs valeurs d'alpha).
    Si votre collection a un alpha < 1, cet outil modifiera définitivement les valeurs d'alpha.

    Notez que cet outil sélectionne les objets de collection en fonction de leurs *origine*
    (c'est-à-dire `offsets`).

    Paramètres
    ----------
    ax : `~matplotlib.axes.Axes`
        Axes avec lequel interagir.
    collection : `matplotlib.collections.Collection` sous-classe
        Collection à partir de laquelle vous voulez sélectionner.
    alpha_other : 0 <= float <= 1
        Pour mettre en évidence une sélection, cet outil définit tous les points sélectionnés
        à une valeur d'alpha de 1 et les points non sélectionnés à *alpha_other*.
    """

    def __init__(self, ax, collection, alpha_other=0.3):
        self.canvas = ax.figure.canvas
        self.collection = collection
        self.alpha_other = alpha_other

        self.xys = collection.get_offsets()
        self.Npts = len(self.xys)

        ## Assurez-vous d'avoir des couleurs séparées pour chaque objet
        self.fc = collection.get_facecolors()
        if len(self.fc) == 0:
            raise ValueError('La collection doit avoir une couleur de face')
        elif len(self.fc) == 1:
            self.fc = np.tile(self.fc, (self.Npts, 1))

        self.poly = PolygonSelector(ax, self.onselect, draw_bounding_box=True)
        self.ind = []

    def onselect(self, verts):
        path = Path(verts)
        self.ind = np.nonzero(path.contains_points(self.xys))[0]
        self.fc[:, -1] = self.alpha_other
        self.fc[self.ind, -1] = 1
        self.collection.set_facecolors(self.fc)
        self.canvas.draw_idle()

    def disconnect(self):
        self.poly.disconnect_events()
        self.fc[:, -1] = 1
        self.collection.set_facecolors(self.fc)
        self.canvas.draw_idle()

Création d'un objet Sélecteur

Dans cette étape, nous allons créer une instance de la classe Sélecteur que nous avons définie dans l'étape 3. Cela nous permettra de sélectionner des points dans le nuage de points à l'aide de l'outil Sélecteur de polygones.

selector = SelectFromCollection(ax, pts)

Sélectionner des points

Dans cette étape, nous allons sélectionner des points dans le nuage de points à l'aide de l'outil Sélecteur de polygones. Nous pouvons sélectionner des points en traçant un polygone autour d'eux. Les points sélectionnés seront mis en évidence tandis que les points non sélectionnés seront assombris.

print("Sélectionnez des points dans la figure en les entourant d'un polygone.")
print("Appuyez sur la touche 'échappement' pour commencer un nouveau polygone.")
print("Essayez de maintenir la touche 'Maj' pour déplacer tous les sommets.")
print("Essayez de maintenir la touche 'Ctrl' pour déplacer un seul sommet.")
plt.show()

Détacher l'objet Sélecteur

Dans cette étape, nous allons détacher l'objet Sélecteur pour libérer les ressources utilisées par l'outil Sélecteur de polygones.

selector.disconnect()

Afficher les points sélectionnés

Dans cette étape, nous allons afficher les coordonnées des points sélectionnés.

print('\nPoints sélectionnés:')
print(selector.xys[selector.ind])

Sommaire

Ce laboratoire montre comment utiliser l'outil Sélecteur de polygones dans Matplotlib pour sélectionner des indices à partir d'un nuage de points. La classe Sélecteur permet à l'utilisateur de sélectionner des points en traçant un polygone autour d'eux. Les points sélectionnés sont mis en évidence tandis que les points non sélectionnés sont assombris. Les indices des points sélectionnés sont enregistrés dans un tableau, qui peut être utilisé pour une analyse ultérieure.