matplotlib
kleurkoppelingen

Basis gebruik

Het gebruik van ingebouwde colormaps is net zo eenvoudig als het doorgeven van de naam van de vereiste colormap (zoals gegeven in de colormaps-referentie ) aan de pcolormesh (zoals pcolormesh of contourf ) die dit verwacht, meestal in de vorm van een cmap trefwoordargument:

import matplotlib.pyplot as plt
import numpy as np

plt.figure()
plt.pcolormesh(np.random.rand(20,20),cmap='hot')
plt.show()

Colormaps zijn vooral handig voor het visualiseren van driedimensionale gegevens op tweedimensionale plots, maar een goede colormap kan ook een goede driedimensionale plot veel duidelijker maken:

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator

# generate example data
import numpy as np
x,y = np.meshgrid(np.linspace(-1,1,15),np.linspace(-1,1,15))
z = np.cos(x*np.pi)*np.sin(y*np.pi)

# actual plotting example
fig = plt.figure()
ax1 = fig.add_subplot(121, projection='3d')
ax1.plot_surface(x,y,z,rstride=1,cstride=1,cmap='viridis')
ax2 = fig.add_subplot(122)
cf = ax2.contourf(x,y,z,51,vmin=-1,vmax=1,cmap='viridis')
cbar = fig.colorbar(cf)
cbar.locator = LinearLocator(numticks=11)
cbar.update_ticks()
for ax in {ax1, ax2}:
    ax.set_xlabel(r'$x$')
    ax.set_ylabel(r'$y$')
    ax.set_xlim([-1,1])
    ax.set_ylim([-1,1])
    ax.set_aspect('equal')

ax1.set_zlim([-1,1])
ax1.set_zlabel(r'$\cos(\pi x) \sin(\p    i y)$')

plt.show()

Aangepaste kleurenkaarten gebruiken

Afgezien van de ingebouwde colormaps die zijn gedefinieerd in de colormaps-referentie (en hun omgekeerde kaarten, met '_r' toegevoegd aan hun naam), kunnen aangepaste colormaps ook worden gedefinieerd. De sleutel is de matplotlib.cm module.

Het onderstaande voorbeeld definieert een zeer eenvoudige kleurenkaart met cm.register_cmap , die een enkele kleur bevat, waarbij de dekking (alfawaarde) van de kleur interpoleert tussen volledig ondoorzichtig en volledig transparant in het gegevensbereik. Merk op dat de belangrijke lijnen vanuit het gezichtspunt van de colormap het importeren van cm , de aanroep naar register_cmap en het doorgeven van de colormap naar plot_surface .

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.cm as cm

# generate data for sphere
from numpy import pi,meshgrid,linspace,sin,cos
th,ph = meshgrid(linspace(0,pi,25),linspace(0,2*pi,51))
x,y,z = sin(th)*cos(ph),sin(th)*sin(ph),cos(th)

# define custom colormap with fixed colour and alpha gradient
# use simple linear interpolation in the entire scale
cm.register_cmap(name='alpha_gradient',
                 data={'red':   [(0.,0,0),
                                 (1.,0,0)],

                       'green': [(0.,0.6,0.6),
                                 (1.,0.6,0.6)],

                       'blue':  [(0.,0.4,0.4),
                                 (1.,0.4,0.4)],

                       'alpha': [(0.,1,1),
                                 (1.,0,0)]})

# plot sphere with custom colormap; constrain mapping to between |z|=0.7 for enhanced effect
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x,y,z,cmap='alpha_gradient',vmin=-0.7,vmax=0.7,rstride=1,cstride=1,linewidth=0.5,edgecolor='b')
ax.set_xlim([-1,1])
ax.set_ylim([-1,1])
ax.set_zlim([-1,1])
ax.set_aspect('equal')

plt.show()

In meer gecompliceerde scenario's kan een lijst met R / G / B (/ A) -waarden worden gedefinieerd waarin matplotlib lineair interpoleert om de kleuren te bepalen die in de overeenkomstige plots worden gebruikt.

Perceptueel uniforme colormaps

De originele standaardkleurenkaart van MATLAB (vervangen in versie R2014b) met de naam jet is alomtegenwoordig vanwege het hoge contrast en de vertrouwdheid (en was de standaard van matplotlib om compatibiliteitsredenen). Ondanks zijn populariteit hebben traditionele colormaps vaak tekortkomingen als het gaat om het nauwkeurig weergeven van gegevens. De waargenomen verandering in deze colormaps komt niet overeen met wijzigingen in gegevens; en een conversie van de kleurenkaart naar grijswaarden (door bijvoorbeeld een figuur af te drukken met een zwart-witprinter) kan informatieverlies veroorzaken.

Perceptueel uniforme colormaps zijn geïntroduceerd om datavisualisatie zo nauwkeurig en toegankelijk mogelijk te maken. Matplotlib introduceerde vier nieuwe, perceptueel uniforme colormaps in versie 1.5, waarvan er één ( viridis genoemd) de standaard vanaf versie 2.0 is. Deze vier colormaps ( viridis , inferno , plasma en magma ) zijn allemaal optimaal vanuit het oogpunt van perceptie, en deze moeten standaard worden gebruikt voor datavisualisatie, tenzij er zeer goede redenen zijn om dit niet te doen. Deze colormaps introduceren zo weinig mogelijk vooringenomenheid (door geen functies te maken waar er nog geen zijn om mee te beginnen), en ze zijn geschikt voor een publiek met verminderde kleurperceptie.

Als een voorbeeld voor het visueel vervormen van gegevens, overweeg de volgende twee plots van bovenaanzicht van piramide-achtige objecten:

Welke van de twee is een echte piramide? Het antwoord is natuurlijk dat ze dat allebei zijn, maar dit is verre van duidelijk uit de plot met de jet colormap:

Deze functie vormt de kern van perceptuele uniformiteit.

Aangepaste discrete kleurenkaart

Als u vooraf gedefinieerde bereiken hebt en specifieke kleuren voor die bereiken wilt gebruiken, kunt u aangepaste colormap declareren. Bijvoorbeeld:

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

x = np.linspace(-2,2,500)
y = np.linspace(-2,2,500)
XX, YY = np.meshgrid(x, y)
Z = np.sin(XX) * np.cos(YY)

cmap = colors.ListedColormap(['red', '#000000','#444444', '#666666', '#ffffff', 'blue', 'orange'])
boundaries = [-1, -0.9, -0.6, -0.3, 0, 0.3, 0.6, 1]
norm = colors.BoundaryNorm(boundaries, cmap.N, clip=True)

plt.pcolormesh(x,y,Z, cmap=cmap, norm=norm)
plt.colorbar()
plt.show()

produceert

Kleur i wordt gebruikt voor waarden tussen grens i en i + 1 . Kleuren kunnen worden opgegeven met namen ( 'red' , 'green' ), HTML-codes ( '#ffaa44' , '#441188' ) of RGB-tupels ( (0.2, 0.9, 0.45) ).