Crear un mapa de colores a partir de una lista de colores #

Para obtener más detalles sobre la creación y manipulación de mapas de colores, consulte Creación de mapas de colores en Matplotlib .

La creación de un mapa de colores a partir de una lista de colores se puede hacer con el LinearSegmentedColormap.from_listmétodo. Debe pasar una lista de tuplas RGB que definen la mezcla de colores de 0 a 1.

Creación de mapas de colores personalizados #

También es posible crear un mapeo personalizado para un mapa de colores. Esto se logra mediante la creación de un diccionario que especifique cómo cambian los canales RGB de un extremo del cmap al otro.

Ejemplo: suponga que desea que el rojo aumente de 0 a 1 en la mitad inferior, que el verde haga lo mismo en la mitad central y el azul en la mitad superior. Entonces usarías:

cdict = {
    'red': (
        (0.0,  0.0, 0.0),
        (0.5,  1.0, 1.0),
        (1.0,  1.0, 1.0),
    ),
    'green': (
        (0.0,  0.0, 0.0),
        (0.25, 0.0, 0.0),
        (0.75, 1.0, 1.0),
        (1.0,  1.0, 1.0),
    ),
    'blue': (
        (0.0,  0.0, 0.0),
        (0.5,  0.0, 0.0),
        (1.0,  1.0, 1.0),
    )
}

Si, como en este ejemplo, no hay discontinuidades en los componentes r, g y b, entonces es bastante simple: el segundo y tercer elemento de cada tupla, arriba, es el mismo, llámelo " y". El primer elemento (" x") define los intervalos de interpolación en el rango completo de 0 a 1, y debe abarcar todo ese rango. En otras palabras, los valores de xdividen el rango de 0 a 1 en un conjunto de segmentos y ydan los valores de color de punto final para cada segmento.

Ahora considere el verde, cdict['green']está diciendo que para:

0 <= x<= 0,25, yes cero; sin verde
0,25 < x<= 0,75, yvaría linealmente de 0 a 1.
0,75 < x<= 1, ypermanece en 1, verde completo.

Si hay discontinuidades, entonces es un poco más complicado. Etiquete los 3 elementos en cada fila en la cdictentrada para un color dado como . Luego, para valores entre y , el valor del color se interpola entre y .(x, y0, y1)xx[i]x[i+1]y1[i]y0[i+1]

Volviendo a un ejemplo de libro de cocina:

cdict = {
    'red': (
        (0.0,  0.0, 0.0),
        (0.5,  1.0, 0.7),
        (1.0,  1.0, 1.0),
    ),
    'green': (
        (0.0,  0.0, 0.0),
        (0.5,  1.0, 0.0),
        (1.0,  1.0, 1.0),
    ),
    'blue': (
        (0.0,  0.0, 0.0),
        (0.5,  0.0, 0.0),
        (1.0,  1.0, 1.0),
    )
}

y mira cdict['red'][1]; porque está diciendo que de 0 a 0,5, el rojo aumenta de 0 a 1, pero luego salta hacia abajo, de modo que de 0,5 a 1, el rojo aumenta de 0,7 a 1. El verde aumenta de 0 a 1 a medida que va de 0 a 0,5, luego vuelve a saltar a 0 y vuelve a subir a 1 a medida que va de 0,5 a 1.y0 != y1xxxx

row i:   x  y0  y1
               /
              /
row i+1: x  y0  y1

Arriba hay un intento de mostrar que para xen el rango x[i]a x[i+1], la interpolación está entre y1[i]y y0[i+1]. Entonces, y0[0]y y1[-1]nunca se usan.

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

# Make some illustrative fake data:

x = np.arange(0, np.pi, 0.1)
y = np.arange(0, 2 * np.pi, 0.1)
X, Y = np.meshgrid(x, y)
Z = np.cos(X) * np.sin(Y) * 10

Mapas de colores de una lista #

colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]  # R -> G -> B
n_bins = [3, 6, 10, 100]  # Discretizes the interpolation into bins
cmap_name = 'my_list'
fig, axs = plt.subplots(2, 2, figsize=(6, 9))
fig.subplots_adjust(left=0.02, bottom=0.06, right=0.95, top=0.94, wspace=0.05)
for n_bin, ax in zip(n_bins, axs.flat):
    # Create the colormap
    cmap = LinearSegmentedColormap.from_list(cmap_name, colors, N=n_bin)
    # Fewer bins will result in "coarser" colomap interpolation
    im = ax.imshow(Z, origin='lower', cmap=cmap)
    ax.set_title("N bins: %s" % n_bin)
    fig.colorbar(im, ax=ax)

N contenedores: 3, N contenedores: 6, N contenedores: 10, N contenedores: 100

Mapas de colores personalizados #

cdict1 = {
    'red': (
        (0.0, 0.0, 0.0),
        (0.5, 0.0, 0.1),
        (1.0, 1.0, 1.0),
    ),
    'green': (
        (0.0, 0.0, 0.0),
        (1.0, 0.0, 0.0),
    ),
    'blue': (
        (0.0, 0.0, 1.0),
        (0.5, 0.1, 0.0),
        (1.0, 0.0, 0.0),
    )
}

cdict2 = {
    'red': (
        (0.0, 0.0, 0.0),
        (0.5, 0.0, 1.0),
        (1.0, 0.1, 1.0),
    ),
    'green': (
        (0.0, 0.0, 0.0),
        (1.0, 0.0, 0.0),
    ),
    'blue': (
        (0.0, 0.0, 0.1),
        (0.5, 1.0, 0.0),
        (1.0, 0.0, 0.0),
    )
}

cdict3 = {
    'red': (
        (0.0, 0.0, 0.0),
        (0.25, 0.0, 0.0),
        (0.5, 0.8, 1.0),
        (0.75, 1.0, 1.0),
        (1.0, 0.4, 1.0),
    ),
    'green': (
        (0.0, 0.0, 0.0),
        (0.25, 0.0, 0.0),
        (0.5, 0.9, 0.9),
        (0.75, 0.0, 0.0),
        (1.0, 0.0, 0.0),
    ),
    'blue': (
        (0.0, 0.0, 0.4),
        (0.25, 1.0, 1.0),
        (0.5, 1.0, 0.8),
        (0.75, 0.0, 0.0),
        (1.0, 0.0, 0.0),
    )
}

# Make a modified version of cdict3 with some transparency
# in the middle of the range.
cdict4 = {
    **cdict3,
    'alpha': (
        (0.0, 1.0, 1.0),
        # (0.25, 1.0, 1.0),
        (0.5, 0.3, 0.3),
        # (0.75, 1.0, 1.0),
        (1.0, 1.0, 1.0),
    ),
}

Ahora usaremos este ejemplo para ilustrar 2 formas de manejar mapas de colores personalizados. Primero, el más directo y explícito:

blue_red1 = LinearSegmentedColormap('BlueRed1', cdict1)

En segundo lugar, cree el mapa explícitamente y regístrelo. Al igual que el primer método, este método funciona con cualquier tipo de mapa de colores, no solo con un mapa de colores segmentado lineal:

mpl.colormaps.register(LinearSegmentedColormap('BlueRed2', cdict2))
mpl.colormaps.register(LinearSegmentedColormap('BlueRed3', cdict3))
mpl.colormaps.register(LinearSegmentedColormap('BlueRedAlpha', cdict4))

Haz la figura, con 4 subtramas:

fig, axs = plt.subplots(2, 2, figsize=(6, 9))
fig.subplots_adjust(left=0.02, bottom=0.06, right=0.95, top=0.94, wspace=0.05)

im1 = axs[0, 0].imshow(Z, cmap=blue_red1)
fig.colorbar(im1, ax=axs[0, 0])

im2 = axs[1, 0].imshow(Z, cmap='BlueRed2')
fig.colorbar(im2, ax=axs[1, 0])

# Now we will set the third cmap as the default.  One would
# not normally do this in the middle of a script like this;
# it is done here just to illustrate the method.

plt.rcParams['image.cmap'] = 'BlueRed3'

im3 = axs[0, 1].imshow(Z)
fig.colorbar(im3, ax=axs[0, 1])
axs[0, 1].set_title("Alpha = 1")

# Or as yet another variation, we can replace the rcParams
# specification *before* the imshow with the following *after*
# imshow.
# This sets the new default *and* sets the colormap of the last
# image-like item plotted via pyplot, if any.
#

# Draw a line with low zorder so it will be behind the image.
axs[1, 1].plot([0, 10 * np.pi], [0, 20 * np.pi], color='c', lw=20, zorder=-1)

im4 = axs[1, 1].imshow(Z)
fig.colorbar(im4, ax=axs[1, 1])

# Here it is: changing the colormap for the current image and its
# colorbar after they have been plotted.
im4.set_cmap('BlueRedAlpha')
axs[1, 1].set_title("Varying alpha")

fig.suptitle('Custom Blue-Red colormaps', fontsize=16)
fig.subplots_adjust(top=0.9)

plt.show()

Mapas de color azul-rojo personalizados, alfa = 1, alfa variable

Referencias

En este ejemplo se muestra el uso de las siguientes funciones, métodos, clases y módulos:

Tiempo total de ejecución del script: (0 minutos 1,919 segundos)

Galería generada por Sphinx-Gallery