Clase Matplotlib.colors.LinearSegmentedColormap en Python

Matplotlib es una increíble biblioteca de visualización en Python para gráficos 2D de arrays. Matplotlib es una biblioteca de visualización de datos multiplataforma basada en arrays NumPy y diseñada para funcionar con la pila SciPy más amplia.
 

matplotlib.colors.LinearSegmentedColarmap

La clase matplotlib.colors.LinearSegmentedColarmap pertenece al módulo matplotlib.colors . El módulo matplotlib.colors se usa para convertir argumentos de color o números a RGBA o RGB. Este módulo se usa para asignar números a colores o conversión de especificación de color en una array de colores 1-D también conocida como mapa de colores.
La clase matplotlib.colors.LinearSegmentedColormap se usa para asignar colores a objetos basados ​​en tablas de búsqueda con la ayuda de segmentos lineales. La tabla para la búsqueda se genera por interpolación lineal para cada color primario, ya que el dominio 0-1 lo divide en cualquier número de segmentos. También se puede utilizar para crear un mapa de colores a partir de segmentos de mapas lineales. Un diccionario con el nombre de datos de segmento está presente con entradas rojas, azules y verdes. Cada entrada debe ser una lista de tuplas x, y0, y1, creando filas de la tabla. Es importante tener en cuenta que las entradas alfabéticas son opcionales. 
Por ejemplo, suponga que desea que el rojo aumente de 0 a 1, que el verde haga lo mismo pero sobre la mitad central y el azul sobre la mitad superior. Entonces usarías el siguiente diccionario:
 

seg_data_dict = 
{‘rojo’: [(0.0, 0.0, 0.0), 
(0.5, 1.0, 1.0), 
(1.0, 1.0, 1.0)],
‘verde’: [(0.0, 0.0, 0.0), 
(0.25, 0.0 , 0.0), 
(0.75, 1.0, 1.0), 
(1.0, 1.0, 1.0)],
‘azul’: [(0.0, 0.0, 0.0), 
(0.5, 0.0, 0.0), 
(1.0, 1.0, 1.0)] }
 

Cada fila de la tabla para un color determinado es una secuencia de la tupla x, y0, y1. En cada secuencia, la x debe incrementarse monótonamente de 0 a 1. Para todos los valores de entrada z que se encuentran entre x[i] y x[i+1], el valor de salida interpolado linealmente de un color dado está entre y1[i] y y0[ i+1]:
 

fila i: x y0 y1 
fila i+1: x y0 y1 
 

Por lo tanto, y0 en la primera fila e y1 en la última fila nunca se usan.
Métodos de la clase: 
 

1. estático from_list (nombre, colores, N = 256, gamma = 1.0): este método se usa para crear un mapa de colores segmentado lineal con el nombre de una secuencia de colores que se mueve uniformemente de colores [0] en val = 0 a colores [-1 ] en valor=1. N representa el número de niveles de cuantificación rgb. Además, la lista de tuplas (valor, color) puede crear una división en el rango de manera desigual.
    
2. reversed(self, name=None): Se utiliza para hacer instancias invertidas del Mapa de colores. 
   parámetros: 
   • name: Es un parámetro opcional que acepta el nombre del mapa de colores invertido en forma de string. Si es Ninguno, el nombre se establece en el nombre del mapa de colores principal + «r».
     Devoluciones: este método devuelve un mapa de colores invertido. 
      
3. set_gamma(self, gamma): Se utiliza para regenerar un mapa de color estableciendo un nuevo valor gamma 
    

Ejemplo 1: 
 

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
 
# some dummy data
a = np.arange(0, np.pi, 0.1)
b = np.arange(0, 2 * np.pi, 0.1)
A, B = np.meshgrid(a, b)
X = np.cos(A) * np.sin(B) * 10
 
# custom segmented color dictionary
 
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))
        }
 
# Creating a modified version of cdict3
# with some transparency
# in the center 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)),
          }
blue_red1 = LinearSegmentedColormap('BlueRed1',
                                    cdict1)
blue_red2 = LinearSegmentedColormap('BlueRed2',
                                    cdict2)
plt.register_cmap(cmap = blue_red2)
 
# optional lut kwarg
plt.register_cmap(name ='BlueRed3',
                  data = cdict3)
plt.register_cmap(name ='BlueRedAlpha',
                  data = cdict4)
figure, axes = plt.subplots(2, 2,
                            figsize =(6, 9))
 
figure.subplots_adjust(left = 0.02,
                       bottom = 0.06,
                       right = 0.95,
                       top = 0.94,
                       wspace = 0.05)
 
# Making 4 different subplots:
img1 = axes[0, 0].imshow(X,
                         interpolation ='nearest',
                         cmap = blue_red1)
 
figure.colorbar(img1, ax = axes[0, 0])
 
cmap = plt.get_cmap('BlueRed2')
img2 = axes[1, 0].imshow(X,
                         interpolation ='nearest',
                         cmap = cmap)
 
figure.colorbar(img2, ax = axes[1, 0])
 
# set the third cmap as the default.
plt.rcParams['image.cmap'] = 'BlueRed3'
 
img3 = axes[0, 1].imshow(X,
                         interpolation ='nearest')
figure.colorbar(img3, ax = axes[0, 1])
axes[0, 1].set_title("1st Alpha")
 
# Draw a line with low zorder to
# keep it behind the image.
axes[1, 1].plot([0, 10 * np.pi],
                [0, 20 * np.pi],
                color ='c',
                lw = 19,
                zorder =-1)
 
img4 = axes[1, 1].imshow(X,
                         interpolation ='nearest')
figure.colorbar(img4, ax = axes[1, 1])
 
# Here it is: changing the colormap
# for the current image and its
# colorbar after they have been plotted.
img4.set_cmap('BlueRedAlpha')
axes[1, 1].set_title("Variation in alpha")
 
figure.subplots_adjust(top = 0.8)
 
plt.show()

Producción: 
 

Ejemplo 2: 
 

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
 
# Make some illustrative fake data:
a = np.arange(0, np.pi, 0.1)
b = np.arange(0, 2 * np.pi, 0.1)
A, B = np.meshgrid(a, b)
X = np.cos(A) * np.sin(B) * 10
 
# colormap froma list
# R -> G -> B
list_colors = [(1, 0, 0),
               (0, 1, 0),
               (0, 0, 1)] 
 
 
# Discretizes the interpolation
# into bins
all_bins = [3, 6, 10, 100]
cmap_name = 'my_list'
figure, axes = plt.subplots(2, 2,
                            figsize =(6, 9))
 
figure.subplots_adjust(left = 0.02,
                       bottom = 0.06,
                       right = 0.95,
                       top = 0.94,
                       wspace = 0.05)
 
for all_bin, ax in zip(all_bins, axes.ravel()):
     
    # Making the colormap
    cm = LinearSegmentedColormap.from_list(
        cmap_name,
        list_colors,
        N = all_bin)
     
    im = ax.imshow(X, interpolation ='nearest',
                   origin ='lower', cmap = cm)
     
    ax.set_title("bin: % s" % all_bin)
    fig.colorbar(im, ax = ax)

Producción: