klienta colormap w Pythonie

Question

Chciałbym stworzyć własną mapę niestandardowych kolorów w python, patrzyłem na niektóre przykłady internetowych i okazało się, Komendy

from matplotlib import cm 
import matplotlib.pyplot as plt 
from matplotlib.colors import LinearSegmentedColormap 

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)) 
     } 

blue_red1 = LinearSegmentedColormap('BlueRed1', cdict1) 
plt.imshow(big,interpolation='nearest', cmap=blue_red1, aspect='auto') 
plt.colorbar() 
plt.show() 

Z powyższego polecenia dostaję mapę kolorów, które jest (czerwony - czarny - niebieski), gdzie czerwona jest maksymalna, a niebieska jest minimalna. Chciałbym stworzyć mapę kolorów, która jest (czarny - biały - czarny). Czy ktoś może mi powiedzieć, co należy zrobić lub jakąkolwiek inną metodę?

Answer 1

Chcesz wszystkie trzy składniki, które mają być zarówno 0 0 a 1, a wszystkie trzy być 1 na 0,5. Tak, masz:

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)) 
     } 

Answer 2

Mam również tworzenie colormap mylące. Model LinearSegmentedColormap jest fajny, ponieważ jest bardzo elastyczny, ale przydaje się przyzwyczajenie do niego przy użyciu LinearSegmentedColormap.

Pierwszy - i być może najważniejsze - rzecz do dokonywania colormaps ten sposób jest to, że rozumieją RGB colors. Zasadniczo każdy kolor ma wartość intensywności od 0 do 1, a wyższe wartości dają więcej tego koloru. W przestrzeni kolorów RGB kolor biały jest reprezentowany przez wszystkie trzy kolory: 1, a czarny to wszystkie trzy kolory 0.

Druga rzecz, która jest ważna, aby nauczyć się tworzyć mapy kolorów w ten sposób, jest następująca: zawsze twórz 2 i 3 wartości każdej krotki tak, aby wygodnie tworzyć proste liniowe mapy kolorów. Ostatecznie możesz zmienić te wartości, aby utworzyć nieciągłości w mapach kolorów, ale to tylko wprowadzi Cię w błąd, gdy zaczniesz.

OK, więc pierwszą wartością w każdej krotce jest "ułamek" mapy kolorów i muszą one dotyczyć od 0 do 1, drugą i trzecią wartością jest intensywność dla tego koloru (dolna i górna granica). Tak więc, aby dokonać colormap że jest 'czarno-biało-czarny', zrobiłbyś:

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) 

Na przykład

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

powodzenia!

Answer 3

Spróbuj cdict1 z

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)) 
     } 

Słownik ten opisuje, w jaki kolory są interpolowane, patrząc na siebie czerwony-zielony-niebieski składnika osobno. Dla każdego komponentu podajesz listę 3-krotnych (x, y0, y1), które określają sposób interpolacji tego komponentu, a każda żądana wartość jest interpolowana między dwoma punktami na liście.

W tym przypadku chcemy zacząć od czerni [RGB = (0,0,0)], zwiększyć do białego [RGB = 1,1,1] w połowie zakresu zakresu danych, a następnie zmniejszyć do czarnego na końcu.

Dla każdej wartości, aby przypisać kolor, mapa będzie najpierw przekonwertować wartość ułamka zakresu wejściowego tak, że ma coś w przedziale [0, 1]. Aby uzyskać poziom czerwonego komponentu, mapa przeskanuje pierwszy element w każdej 3-krotnej na "czerwonej" liście i chwyci największą, nie przekraczającą twojej frakcji. Przydzielony poziom czerwieni zostanie interpolowany między elementem y1 tego 3-krotnego a elementem y0 następnej 3-tki, w oparciu o różnicę w wartości x.

Podobnie do niebieskich i zielonych komponentów.

Answer 4

Co jest warte, jest też prostsza metoda.

Pełna forma LinearSegmentedColormap daje możliwość posiadania "twardych" przystanków i gradientów w tej samej mapie kolorów, więc jest to bardzo skomplikowane. Istnieje jednak konstruktor wygody dla prostych spraw, takich jak to, co opisujesz.

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()