Matplotlib Tricontour Smooth User

Introducción

Esta práctica te guiará a través del proceso de creación de tricontornos de alta resolución en mallas triangulares definidas por el usuario utilizando Matplotlib. Aprenderás cómo crear una Triangulación, refinar datos y trazar la triangulación y los contornos de iso-valor de alta resolución.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haz 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 tengas 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 tienes problemas durante el aprendizaje, no dudes en preguntar a Labby. Proporciona retroalimentación después de la sesión y resolveremos rápidamente el problema para ti.

Función de prueba analítica

En este paso, definimos una función de prueba analítica que se utilizará para generar valores de z para la triangulación. La función se llama function_z y toma dos argumentos, x e y. Calcula z en función de los valores de x e y y devuelve los valores normalizados de z.

def function_z(x, y):
    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 = -(2 * (np.exp((r1 / 10)**2) - 1) * 30. * np.cos(7. * theta1) +
          (np.exp((r2 / 10)**2) - 1) * 30. * np.cos(11. * theta2) +
          0.7 * (x**2 + y**2))
    return (np.max(z) - z) / (np.max(z) - np.min(z))

Creando una Triangulación

En este paso, creamos las coordenadas x e y de los puntos utilizando np.linspace y np.repeat. Luego utilizamos la function_z definida en el Paso 1 para calcular los valores de z. Finalmente, creamos la Triangulación utilizando tri.Triangulation.

n_angles = 20
n_radii = 10
min_radius = 0.15
radii = np.linspace(min_radius, 0.95, n_radii)

angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += np.pi / n_angles

x = (radii * np.cos(angles)).flatten()
y = (radii * np.sin(angles)).flatten()
z = function_z(x, y)

triang = tri.Triangulation(x, y)
triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
                         y[triang.triangles].mean(axis=1))
                < min_radius)

Refinar datos

En este paso, utilizamos tri.UniformTriRefiner para refinar los datos. Utilizamos el método refine_field para refinar los valores de z y crear una nueva Triangulación con una resolución más alta.

refiner = tri.UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(z, subdiv=3)

Graficar la Triangulación y los contornos de iso-valor de alta resolución

En este paso, graficamos la Triangulación y los contornos de iso-valor de alta resolución utilizando ax.triplot, ax.tricontourf y ax.tricontour.

fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.triplot(triang, lw=0.5, color='white')

levels = np.arange(0., 1., 0.025)
ax.tricontourf(tri_refi, z_test_refi, levels=levels, cmap='terrain')
ax.tricontour(tri_refi, z_test_refi, levels=levels,
              colors=['0.25', '0.5', '0.5', '0.5', '0.5'],
              linewidths=[1.0, 0.5, 0.5, 0.5, 0.5])

ax.set_title("High-resolution tricontouring")

plt.show()

Resumen

En este laboratorio, aprendiste cómo crear contornos tridimensionales de alta resolución en una malla triangular definida por el usuario utilizando Matplotlib. Aprendiste cómo crear una Triangulación, refinar datos y graficar la Triangulación y los contornos de iso-valor de alta resolución.