Introducción
En este laboratorio, aprenderemos a usar Matplotlib para mapear mapas de colores a los datos de manera no lineal. Demonstraremos el uso de norm para crear normalizaciones logarítmicas, de ley de potencia, logarítmicas simétricas y personalizadas. También aprenderemos a usar BoundaryNorm para proporcionar límites para los colores.
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.
Lognorm
Crearemos una pequeña protuberancia con una cresta saliendo por la cima, lo que requiere que el eje z/color esté en una escala logarítmica, para que veamos tanto la protuberancia como la cresta.
N = 100
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X * 10)**2 - (Y * 10)**2)
Z = Z1 + 50 * Z2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolor(X, Y, Z,
norm=colors.LogNorm(vmin=Z.min(), vmax=Z.max()),
cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolor(X, Y, Z, cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='max')
PowerNorm
Crearemos una tendencia de ley de potencia en X que obscura parcialmente una onda sinusoidal rectificada en Y. Luego eliminaremos la ley de potencia usando una PowerNorm.
X, Y = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.)) * X**2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X, Y, Z1, norm=colors.PowerNorm(gamma=1. / 2.),
cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolormesh(X, Y, Z1, cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='max')
SymLogNorm
Crearemos dos protuberancias, una negativa y una positiva, con la protuberancia positiva teniendo 5 veces la amplitud. Linealmente, no podemos ver detalles en la protuberancia negativa. Escalaremos los datos positivos y negativos por separado en escala logarítmica usando una SymLogNorm.
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z = 5 * np.exp(-X**2 - Y**2)
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X, Y, Z,
norm=colors.SymLogNorm(linthresh=0.03, linscale=0.03,
vmin=-1.0, vmax=1.0, base=10),
cmap='RdBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='both')
pcm = ax[1].pcolormesh(X, Y, Z, cmap='RdBu_r', vmin=-np.max(Z),
shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='both')
Custom Norm
Crearemos un ejemplo con una normalización personalizada. Este ejemplo utiliza el ejemplo anterior y normaliza los datos negativos de manera diferente a los positivos.
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
Z = (Z1 - Z2) * 2
class MidpointNormalize(colors.Normalize):
def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
self.midpoint = midpoint
super().__init__(vmin, vmax, clip)
def __call__(self, value, clip=None):
x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
return np.ma.masked_array(np.interp(value, x, y))
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X, Y, Z,
norm=MidpointNormalize(midpoint=0.),
cmap='RdBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='both')
pcm = ax[1].pcolormesh(X, Y, Z, cmap='RdBu_r', vmin=-np.max(Z),
shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='both')
BoundaryNorm
Proporcionaremos límites para los colores usando BoundaryNorm.
fig, ax = plt.subplots(3, 1, figsize=(8, 8))
ax = ax.flatten()
bounds = np.linspace(-1, 1, 10)
norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)
pcm = ax[0].pcolormesh(X, Y, Z,
norm=norm,
cmap='RdBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='both', orientation='vertical')
bounds = np.array([-0.25, -0.125, 0, 0.5, 1])
norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)
pcm = ax[1].pcolormesh(X, Y, Z, norm=norm, cmap='RdBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='both', orientation='vertical')
pcm = ax[2].pcolormesh(X, Y, Z, cmap='RdBu_r', vmin=-np.max(Z1),
shading='nearest')
fig.colorbar(pcm, ax=ax[2], extend='both', orientation='vertical')
plt.show()
Resumen
En este laboratorio, aprendimos cómo usar Matplotlib para mapear mapas de colores a datos de maneras no lineales usando varias normalizaciones como LogNorm, PowerNorm, SymLogNorm y normalizaciones personalizadas. También aprendimos cómo usar BoundaryNorm para proporcionar límites para los colores.