Colormap personnalisé en Python

pour ce que ça vaut, il y a aussi une méthode plus simple.

La forme complète de LinearSegmentedColormap Vous donne la possibilité d'avoir des butées et des gradients "durs" dans le même colormap, donc c'est nécessairement complexe. Cependant, il ya un constructeur de commodité pour les cas simples tels que ce que vous décrivez.

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

cmap = LinearSegmentedColormap.from_list('mycmap', ['black', 'white', 'black'])

fig, ax = plt.subplots()
im = ax.imshow(np.random.random((10, 10)), cmap=cmap, interpolation='nearest')
fig.colorbar(im)
plt.show()

vous voulez que les trois composants soient 0 à 0 et 1, et que les trois soient 1 à 0.5. Donc, vous avez:

cdict1 = {'red':  ((0.0, 0.0, 0.0),   # <- at 0.0, the red component is 0
                   (0.5, 1.0, 1.0),   # <- at 0.5, the red component is 1
                   (1.0, 0.0, 0.0)),  # <- at 1.0, the red component is 0

         'green': ((0.0, 0.0, 0.0),   # <- etc.
                   (0.5, 1.0, 1.0),
                   (1.0, 0.0, 0.0)),

         'blue':  ((0.0, 0.0, 0.0),
                   (0.5, 1.0, 1.0),
                   (1.0, 0.0, 0.0))
         }

j'ai aussi trouvé la création de colormap confuse. LinearSegmentedColormap c'est agréable car il est très souple, mais cdict faut s'habituer à.

la première - et peut - être la plus importante-chose à faire colormaps de cette façon est que vous comprenez couleurs RVB. Fondamentalement, chaque couleur a une valeur d'intensité de 0 à 1, et les valeurs plus élevées donnent plus de cette couleur. En l'espace colorimétrique RVB, le blanc est représenté par les trois couleurs 1, et le noir est les trois les couleurs 0.

la deuxième chose qui est importante pour apprendre à faire des colormaps de cette façon est ceci: toujours faire les valeurs 2nd et 3rd de chaque tuple la même jusqu'à ce que vous deveniez à l'aise avec la création de simples colormaps linéaires. Finalement, vous pouvez changer ces valeurs pour faire des discontinuités dans la carte des couleurs, mais il ne confondez vous que vous obtenez commencé.

OK, donc la première valeur dans chaque tuple est la 'fraction' du colormap et celle - ci doit aller de 0 à 1, la les deuxième et troisième valeurs de l'intensité de cette couleur (limites inférieure et supérieure). Donc, pour faire un colormap qui est 'noir-blanc-noir', vous feriez:

cdict1 = {
    'red':   ((0.0, 0.0, 0.0),
              (0.5, 1.0, 1.0),
              (1.0, 0.0, 0.0)),

    'green': ((0.0, 0.0, 0.0),
              (0.5, 1.0, 1.0),
              (1.0, 0.0, 0.0)),

    'blue':   ((0.0, 0.0, 0.0),
              (0.5, 1.0, 1.0),
              (1.0, 0.0, 0.0)),
         }

black_white_black = LinearSegmentedColormap('BlackWhiteBlack', cdict1)

Par exemple,

plt.imshow(np.arange(100).reshape(10,10), cmap=black_white_black, aspect='auto')
plt.colorbar()

Bonne Chance!

essayez un cdict1 de

cdict1 = {'red':   ((0.0, 0.0, 0.0),
                    (0.5, 1.0, 1.0),
                    (1.0, 0.0, 0.0)),

         'green': ((0.0, 0.0, 0.0),
                   (0.5, 1.0, 1.0),
                   (1.0, 0.0, 0.0)),

         'blue':  ((0.0, 0.0, 0.0),
                   (0.5, 1.0, 1.0),
                   (1.0, 0.0, 0.0))
         }

ce dictionnaire décrit comment les couleurs sont interpolées, en regardant chaque composante rouge-vert-bleu individuellement. Pour chaque component vous lui donnez une liste de 3-tuples (x, y0, y1) qui spécifient comment interpoler ce component, et chaque valeur que vous voulez est interpolée entre deux points dans la liste.

dans ce cas, nous voulons commencer par le noir [RGB=(0,0)], passer au blanc [RGB=1,1,1] à mi-distance de la plage de données, puis diminution de back to black " à la fin.

pour chaque valeur assignée à une couleur, la map convertira d'abord cette valeur en une fraction de la plage d'entrée pour qu'elle ait quelque chose dans la plage [0, 1]. Pour obtenir le niveau de la composante rouge, la carte numérisera le premier élément dans chaque 3-tuples dans la liste "rouge" et saisira le plus grand ne dépassant pas votre fraction. Le niveau rouge assigné sera interpolé entre l'élément y1 de ce 3-tuple et l'élément y0 du 3-tuple suivant, basé sur la différence de valeur de X.

et de même pour les composants bleu et vert.