Ik zou graag willen weten hoe ik de kleurvolgorde van een bepaalde kleurenkaart eenvoudig kan omdraaien om deze te gebruiken met plot_surface.
Antwoord 1, autoriteit 100%
De standaard kleurenkaarten hebben ook allemaal een omgekeerde versie. Ze hebben dezelfde namen met _raan het einde geplakt. (Documentatie hier.)
Antwoord 2, autoriteit 5%
De oplossing is vrij eenvoudig. Stel dat u het kleurenkaartschema “herfst” wilt gebruiken. De standaardversie:
cmap = matplotlib.cm.autumn
Om het kleurenspectrum van de kleurenkaart om te keren, gebruikt u de functie get_cmap() en voegt u ‘_r’ als volgt toe aan de titel van de kleurenkaart:
cmap_reversed = matplotlib.cm.get_cmap('autumn_r')
Antwoord 3, autoriteit 5%
In matplotlib is een kleurenkaart geen lijst, maar bevat de lijst met zijn kleuren als colormap.colors. En de module matplotlib.colorsbiedt een functie ListedColormap()om een kleurenkaart uit een lijst te genereren. U kunt dus elke kleurenkaart omkeren door
. te doen
colormap_r = ListedColormap(colormap.colors[::-1])
Antwoord 4, autoriteit 4%
Vanaf Matplotlib 2.0 is er een reversed()methode voor ListedColormapen LinearSegmentedColorMapobjecten, dus je kunt gewoon
cmap_reversed = cmap.reversed()
Hieris de documentatie.
Antwoord 5, autoriteit 2%
Omdat een LinearSegmentedColormapsis gebaseerd op een woordenboek van rood, groen en blauw, is het noodzakelijk om elk item om te draaien:
import matplotlib.pyplot as plt
import matplotlib as mpl
def reverse_colourmap(cmap, name = 'my_cmap_r'):
"""
In:
cmap, name
Out:
my_cmap_r
Explanation:
t[0] goes from 0 to 1
row i: x y0 y1 -> t[0] t[1] t[2]
/
/
row i+1: x y0 y1 -> t[n] t[1] t[2]
so the inverse should do the same:
row i+1: x y1 y0 -> 1-t[0] t[2] t[1]
/
/
row i: x y1 y0 -> 1-t[n] t[2] t[1]
"""
reverse = []
k = []
for key in cmap._segmentdata:
k.append(key)
channel = cmap._segmentdata[key]
data = []
for t in channel:
data.append((1-t[0],t[2],t[1]))
reverse.append(sorted(data))
LinearL = dict(zip(k,reverse))
my_cmap_r = mpl.colors.LinearSegmentedColormap(name, LinearL)
return my_cmap_r
Zie dat het werkt:
my_cmap
<matplotlib.colors.LinearSegmentedColormap at 0xd5a0518>
my_cmap_r = reverse_colourmap(my_cmap)
fig = plt.figure(figsize=(8, 2))
ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15])
ax2 = fig.add_axes([0.05, 0.475, 0.9, 0.15])
norm = mpl.colors.Normalize(vmin=0, vmax=1)
cb1 = mpl.colorbar.ColorbarBase(ax1, cmap = my_cmap, norm=norm,orientation='horizontal')
cb2 = mpl.colorbar.ColorbarBase(ax2, cmap = my_cmap_r, norm=norm, orientation='horizontal')
BEWERKEN
Ik krijg de opmerking van gebruiker3445587 niet. Het werkt prima op de regenboogkleurenkaart:
cmap = mpl.cm.jet
cmap_r = reverse_colourmap(cmap)
fig = plt.figure(figsize=(8, 2))
ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15])
ax2 = fig.add_axes([0.05, 0.475, 0.9, 0.15])
norm = mpl.colors.Normalize(vmin=0, vmax=1)
cb1 = mpl.colorbar.ColorbarBase(ax1, cmap = cmap, norm=norm,orientation='horizontal')
cb2 = mpl.colorbar.ColorbarBase(ax2, cmap = cmap_r, norm=norm, orientation='horizontal')
Maar het werkt vooral goed voor aangepaste gedeclareerde kleurenkaarten, omdat er geen standaard _ris voor aangepaste gedeclareerde kleurenkaarten. Volgend voorbeeld uit http://matplotlib.org/examples/pylab_examples/custom_cmap.html:
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 = mpl.colors.LinearSegmentedColormap('BlueRed1', cdict1)
blue_red1_r = reverse_colourmap(blue_red1)
fig = plt.figure(figsize=(8, 2))
ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15])
ax2 = fig.add_axes([0.05, 0.475, 0.9, 0.15])
norm = mpl.colors.Normalize(vmin=0, vmax=1)
cb1 = mpl.colorbar.ColorbarBase(ax1, cmap = blue_red1, norm=norm,orientation='horizontal')
cb2 = mpl.colorbar.ColorbarBase(ax2, cmap = blue_red1_r, norm=norm, orientation='horizontal')
Antwoord 6
Er is (nog) geen ingebouwde manier om willekeurige kleurenkaarten om te keren, maar een eenvoudige oplossing is om de kleurenbalk niet te wijzigen, maar om een omkerend object Normalize te maken:
from matplotlib.colors import Normalize
class InvertedNormalize(Normalize):
def __call__(self, *args, **kwargs):
return 1 - super(InvertedNormalize, self).__call__(*args, **kwargs)
U kunt dit vervolgens gebruiken met plot_surfaceen andere Matplotlib-plotfuncties door bijv.
inverted_norm = InvertedNormalize(vmin=10, vmax=100)
ax.plot_surface(..., cmap=<your colormap>, norm=inverted_norm)
Dit werkt met elke Matplotlib-kleurenkaart.
Antwoord 7
Er zijn twee soorten LinearSegmentedColormaps. In sommige wordt de _segmentdata expliciet gegeven, bijvoorbeeld voor jet:
>>> cm.jet._segmentdata
{'blue': ((0.0, 0.5, 0.5), (0.11, 1, 1), (0.34, 1, 1), (0.65, 0, 0), (1, 0, 0)), 'red': ((0.0, 0, 0), (0.35, 0, 0), (0.66, 1, 1), (0.89, 1, 1), (1, 0.5, 0.5)), 'green': ((0.0, 0, 0), (0.125, 0, 0), (0.375, 1, 1), (0.64, 1, 1), (0.91, 0, 0), (1, 0, 0))}
Voor regenboog wordt _segmentdata als volgt gegeven:
>>> cm.rainbow._segmentdata
{'blue': <function <lambda> at 0x7fac32ac2b70>, 'red': <function <lambda> at 0x7fac32ac7840>, 'green': <function <lambda> at 0x7fac32ac2d08>}
We kunnen de functies vinden in de bron van matplotlib, waar ze worden gegeven als
_rainbow_data = {
'red': gfunc[33], # 33: lambda x: np.abs(2 * x - 0.5),
'green': gfunc[13], # 13: lambda x: np.sin(x * np.pi),
'blue': gfunc[10], # 10: lambda x: np.cos(x * np.pi / 2)
}
Alles wat je wilt is al gedaan in matplotlib, bel gewoon cm.revcmap, dat beide typen segmentgegevens omkeert, dus
cm.revcmap(cm.rainbow._segmentdata)
zou het werk moeten doen – u kunt er eenvoudig een nieuwe LinearSegmentData van maken. In revcmap wordt de omkering van functiegebaseerde SegmentData gedaan met
def _reverser(f):
def freversed(x):
return f(1 - x)
return freversed
terwijl de andere lijsten zoals gewoonlijk worden omgekeerd
valnew = [(1.0 - x, y1, y0) for x, y0, y1 in reversed(val)]
Dus eigenlijk is alles wat je wilt,
def reverse_colourmap(cmap, name = 'my_cmap_r'):
return mpl.colors.LinearSegmentedColormap(name, cm.revcmap(cmap._segmentdata))