Tracé en ligne de niveau haute résolution avec Matplotlib

Introduction

Ce tutoriel montre comment générer des graphes de tricontours haute résolution avec Matplotlib. La tricontouring est une technique utilisée pour représenter des données sur un maillage triangulaire non structuré. Elle est souvent utilisée lorsque les données sont collectées à des points espacés de manière irrégulière, ou lorsque les données sont intrinsèquement triangulaires par nature. Le tutoriel montrera comment générer un ensemble aléatoire de points, effectuer une triangulation de Delaunay sur ces points, masquer certaines des triangles dans le maillage, raffiner et interpoler les données, et finalement tracer les données raffinées à l'aide de la fonction tricontour de 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 des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques requises

La première étape consiste à importer les bibliothèques requises. Ce tutoriel utilisera NumPy et Matplotlib.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.tri import TriAnalyzer, Triangulation, UniformTriRefiner

Définir la fonction de test

Ensuite, nous définissons une fonction qui représente les résultats d'une expérience. Cette fonction sera utilisée pour générer les points de données de test.

def experiment_res(x, y):
    """Une fonction analytique représentant les résultats de l'expérience."""
    x = 2 * x
    r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2)
    theta1 = np.arctan2(0.5 - x, 0.5 - y)
    r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
    theta2 = np.arctan2(-x - 0.2, -y - 0.2)
    z = (4 * (np.exp((r1/10)**2) - 1) * 30 * np.cos(3 * theta1) +
         (np.exp((r2/10)**2) - 1) * 30 * np.cos(5 * theta2) +
         2 * (x**2 + y**2))
    return (np.max(z) - z) / (np.max(z) - np.min(z))

Générer des points de données de test

Nous générons un ensemble de points de données de test aléatoires, avec des valeurs de x et y comprises entre -1 et 1. Nous générons également un ensemble correspondant de valeurs de z à l'aide de la fonction experiment_res définie à l'étape 2.

## Paramètres utilisateur pour les points de données de test

## Nombre de points de données de test, testé de 3 à 5000 pour subdiv=3
n_test = 200

## Points aléatoires
random_gen = np.random.RandomState(seed=19680801)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)

Effectuer une triangulation de Delaunay

Nous effectuons une triangulation de Delaunay sur les points de données de test à l'aide de la fonction Triangulation du module matplotlib.tri.

## maillage avec triangulation de Delaunay
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]

Masquer certains triangles

Nous masquons certains des triangles du maillage pour simuler des données invalidées. Nous sélectionnons aléatoirement un sous-ensemble de triangles en fonction du paramètre init_mask_frac.

## Certaines données invalides sont masquées
mask_init = np.zeros(ntri, dtype=bool)
masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)

Améliorer la triangulation

Nous utilisons un TriAnalyzer pour améliorer la triangulation en éliminant les triangles mal formés (plats) sur la bordure de la triangulation. Nous appliquons ensuite le masque à la triangulation en utilisant set_mask.

## masquage des triangles mal formés à la bordure du maillage triangulaire.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)

Affiner et interpoler les données

Nous affinons et interpolons les données à l'aide d'un UniformTriRefiner.

## raffinement des données
refiner = UniformTriRefiner(tri)
tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

Tracer les données

Nous traçons les données affinées à l'aide de la fonction tricontour de Matplotlib.

## Options graphiques pour le tracé en ligne de niveau
levels = np.arange(0., 1., 0.025)

fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.set_title("Filtrer un maillage de Delaunay\n"
             "(application au tracé en ligne de niveau haute résolution)")

## tracé des contours des données affinées (calculées) :
ax.tricontour(tri_refi, z_test_refi, levels=levels, cmap='Blues',
              linewidths=[2.0, 0.5, 1.0, 0.5])

plt.show()

Sommaire

Ce tutoriel a démontré comment générer des tracés en ligne de niveau haute résolution avec Matplotlib. Nous avons commencé par générer un ensemble de points de données de test aléatoires, effectué une triangulation de Delaunay sur ces points, masqué certains des triangles dans le maillage, affiné et interpolé les données, et finalement tracé les données affinées à l'aide de la fonction tricontour de Matplotlib.

Tricontour lisse de Delaunay