Tricontorno de Alta Resolución con Matplotlib

Introducción

Este tutorial demuestra cómo generar gráficos de tricontorno de alta resolución con Matplotlib. El tricontorno es una técnica utilizada para representar datos en una malla triangular no estructurada. A menudo se utiliza cuando los datos se recopilan en puntos espaciados irregularmente, o cuando los datos son inherentesmente triangulares por naturaleza. El tutorial mostrará cómo generar un conjunto aleatorio de puntos, realizar una triangulación de Delaunay en esos puntos, ocultar algunas de las triángulos en la malla, refinar e interpolar los datos y, finalmente, trazar los datos refinados utilizando la función tricontour de 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

El primer paso es importar las bibliotecas necesarias. En este tutorial se utilizarán NumPy y Matplotlib.

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

Definir la función de prueba

A continuación, definimos una función que representa los resultados de un experimento. Esta función se utilizará para generar los puntos de datos de prueba.

def experiment_res(x, y):
    """Una función analítica que representa los resultados del experimento."""
    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))

Generar puntos de datos de prueba

Generamos un conjunto de puntos de datos de prueba aleatorios, con valores de x e y entre -1 y 1. También generamos un conjunto correspondiente de valores de z utilizando la función experiment_res definida en el paso 2.

## User parameters for data test points

## Número de puntos de datos de prueba, probado de 3 a 5000 para subdiv=3
n_test = 200

## Puntos aleatorios
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)

Realizar una triangulación de Delaunay

Realizamos una triangulación de Delaunay en los puntos de datos de prueba utilizando la función Triangulation del módulo matplotlib.tri.

## malla con triangulación de Delaunay
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]

Ocultar algunos triángulos

Ocultamos algunos de los triángulos de la malla para simular datos invalidados. Seleccionamos aleatoriamente un subconjunto de triángulos basado en el parámetro init_mask_frac.

## Algunos datos no válidos se ocultan
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)

Mejorar la triangulación

Utilizamos un TriAnalyzer para mejorar la triangulación eliminando triángulos mal formados (planos) del borde de la triangulación. Luego aplicamos la máscara a la triangulación utilizando set_mask.

## mascarando triángulos mal formados en el borde de la malla triangular.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)

Mezclar y interpolar datos

Mezclamos e interpolamos los datos utilizando un UniformTriRefiner.

## Mezclando los datos
refiner = UniformTriRefiner(tri)
tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

Graficar los datos

Graficamos los datos refinados utilizando la función tricontour de Matplotlib.

## Opciones gráficas para el trazado de contornos
niveles = np.arange(0., 1., 0.025)

fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.set_title("Filtrado de una malla de Delaunay\n"
             "(aplicación al trazado de contornos de alta resolución)")

## trazado de los contornos de los datos refinados (computados):
ax.tricontour(tri_refi, z_test_refi, niveles=niveles, cmap='Blues',
              linewidths=[2.0, 0.5, 1.0, 0.5])

plt.show()

Resumen

Este tutorial demostró cómo generar gráficos de trazado de contornos de alta resolución con Matplotlib. Comenzamos generando un conjunto de puntos de datos de prueba aleatorios, realizando una triangulación de Delaunay en esos puntos, ocultando algunos de los triángulos de la malla, refinando e interpolando los datos y, finalmente, graficando los datos refinados utilizando la función tricontour de Matplotlib.

Tricontorno Suave de Delaunay