matplotlib.axes.Axes.pcolormesh #

Assi. pcolormesh ( * args , alpha = None , norm = None , cmap = None , vmin = None , vmax = None , shading = None , antialiased = False , data = None , ** kwargs ) [fonte] #

Crea un grafico pseudocolore con una griglia rettangolare non regolare.

Firma chiamata:

pcolormesh([X, Y,] C, **kwargs)

X e Y possono essere usati per specificare gli angoli dei quadrilateri.

Suggerimento

pcolormeshè simile a pcolor. È molto più veloce e preferito nella maggior parte dei casi. Per una discussione dettagliata sulle differenze vedere Differenze tra pcolor() e pcolormesh() .

Parametri :

C simile a un array 2D

I valori mappati a colori. La mappatura dei colori è controllata da cmap , norm , vmin e vmax .

X, Y simile a un array, facoltativo

Le coordinate degli angoli dei quadrilateri di un pcolormesh:

(X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])
                      +-----+
                      |     |
                      +-----+
    (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])

Si noti che l'indice di colonna corrisponde alla coordinata x e l'indice di riga corrisponde a y. Per i dettagli, vedere la sezione Note di seguito.

Se shading='flat'le dimensioni di X e Y dovessero essere maggiori di una di quelle di C , e il quadrilatero è colorato a causa del valore in . Se X , Y e C hanno dimensioni uguali, verrà generato un avviso e l'ultima riga e colonna di C verrà ignorata.C[i, j]

Se shading='nearest'o 'gouraud', le dimensioni di X e Y dovrebbero essere le stesse di C (in caso contrario, verrà sollevato un ValueError). Perché 'nearest'il colore è centrato su . Per , viene eseguita un'interpolazione uniforme tra gli angoli del quadrilatero.C[i, j](X[i, j], Y[i, j])'gouraud'

Se X e/o Y sono array 1-D o vettori colonna, verranno espansi secondo necessità negli array 2D appropriati, creando una griglia rettangolare.

cmap str o Colormap, predefinito: rcParams["image.cmap"](predefinito: 'viridis')

L'istanza Colormap o il nome registrato della mappa colori utilizzato per mappare i dati scalari ai colori.

norm str o Normalize, facoltativo

Il metodo di normalizzazione utilizzato per ridimensionare i dati scalari nell'intervallo [0, 1] prima della mappatura ai colori utilizzando cmap . Per impostazione predefinita, viene utilizzato un ridimensionamento lineare, mappando il valore più basso su 0 e il più alto su 1.

Se indicato, può essere uno dei seguenti:

Un'istanza di Normalizeo una delle sue sottoclassi (vedere Normalizzazione della mappa dei colori ).
Un nome di scala, ad esempio "linear", "log", "symlog", "logit", ecc. Per un elenco delle scale disponibili, chiamare matplotlib.scale.get_scale_names(). NormalizeIn tal caso, una sottoclasse adatta viene generata dinamicamente e istanziata.

vmin, vmax float, facoltativo

Quando si utilizzano dati scalari e nessuna norma esplicita , vmin e vmax definiscono l'intervallo di dati coperto dalla mappa dei colori. Per impostazione predefinita, la mappa dei colori copre l'intero intervallo di valori dei dati forniti. È un errore utilizzare vmin / vmax quando viene fornita un'istanza di norma (ma l'utilizzo di un nome di norma insieme a vmin / vmax è accettabile).str

edgecolors {'none', None, 'face', color, color sequence}, facoltativo

Il colore dei bordi. Il valore predefinito è 'nessuno'. Possibili valori:

'none' o '': nessun bordo.
Nessuno : rcParams["patch.edgecolor"](predefinito: 'black') verrà utilizzato. Si noti che attualmente rcParams["patch.force_edgecolor"](default: False) deve essere True affinché funzioni.
'faccia': usa il colore della faccia adiacente.
Un colore o una sequenza di colori imposterà il colore del bordo.

La forma singolare edgecolor funziona come alias.

alfa float, predefinito: Nessuno

Il valore di fusione alfa, compreso tra 0 (trasparente) e 1 (opaco).

shading {'flat', 'nearest', 'gouraud', 'auto'}, facoltativo

Lo stile di riempimento per il quadrilatero; il valore predefinito è 'flat' o rcParams["pcolor.shading"](predefinito: 'auto'). Possibili valori:

'flat': viene utilizzato un colore a tinta unita per ogni quad. Il colore del quadrato (i, j), (i+1, j), (i, j+1), (i+1, j+1) è dato da . Le dimensioni di X e Y dovrebbero essere maggiori di una di quelle di C ; se sono uguali a C , viene generato un avviso di deprecazione e l'ultima riga e colonna di C vengono eliminate.C[i, j]
'più vicino': ogni punto della griglia avrà un colore centrato su di esso, che si estende a metà strada tra i centri della griglia adiacenti. Le dimensioni di X e Y devono essere le stesse di C .
'gouraud': Ogni quad sarà Gouraud ombreggiato: Il colore degli angoli (i', j') è dato da . I valori di colore dell'area intermedia vengono interpolati dai valori degli angoli. Le dimensioni di X e Y devono essere le stesse di C . Quando si utilizza l'ombreggiatura Gouraud, edgecolors viene ignorato.C[i', j']
'auto': scegli 'piatto' se le dimensioni di X e Y sono maggiori di una unità rispetto a C . Scegli "più vicino" se le dimensioni sono le stesse.

Vedere le griglie pcolormesh e l'ombreggiatura per ulteriori descrizioni.

snap bool, predefinito: falso

Se agganciare la mesh ai limiti dei pixel.

bool rasterizzato , facoltativo

Rasterizza pcolormesh durante il disegno di grafica vettoriale. Questo può velocizzare il rendering e produrre file più piccoli per set di dati di grandi dimensioni. Vedere anche Rasterizzazione per la grafica vettoriale .

Resi :

matplotlib.collections.QuadMesh

Altri parametri :

oggetto indicizzabile dei dati , facoltativo

Se fornito, tutti i parametri accettano anche una stringa s, che viene interpretata come data[s](a meno che ciò non sollevi un'eccezione).

**kwargs

Inoltre, sono consentiti i seguenti argomenti. Vengono passati al QuadMeshcostruttore:

Proprietà	Descrizione
`agg_filter`	una funzione di filtro, che accetta un array float (m, n, 3) e un valore dpi e restituisce un array (m, n, 3) e due offset dall'angolo in basso a sinistra dell'immagine
`alpha`	tipo array o scalare o None
`animated`	bool
`antialiased`o aa o antialias	bool o elenco di bool
`array`	(M, N) tipo array o M*N tipo array
`capstyle`	`CapStyle`o {'culo', 'sporgente', 'rotondo'}
`clim`	(vmin: float, vmax: float)
`clip_box`	`Bbox`
`clip_on`	bool
`clip_path`	Patch o (Percorso, Trasforma) o Nessuno
`cmap`	`Colormap`o str o Nessuno
`color`	colore o elenco di tuple rgba
`edgecolor`o ec o edgecolors	colore o elenco di colori o 'volto'
`facecolor`o facecolors o fc	colore o elenco di colori
`figure`	`Figure`
`gid`	str
`hatch`	{'/', '\', '\|', '-', '+', 'x', 'o', 'O', '.', '*'}
`in_layout`	bool
`joinstyle`	`JoinStyle`o {'mitre', 'round', 'bevel'}
`label`	oggetto
`linestyle`o trattini o stili di linea o ls	str o tuple o loro elenchi
`linewidth`o linewidths o lw	float o lista di float
`mouseover`	bool
`norm`	`Normalize`o str o Nessuno
`offset_transform`o transOffset	sconosciuto
`offsets`	(N, 2) o (2,) simile a un array
`path_effects`	`AbstractPathEffect`
`picker`	Nessuno o bool o float o richiamabile
`pickradius`	sconosciuto
`rasterized`	bool
`sketch_params`	(scala: float, lunghezza: float, casualità: float)
`snap`	bool o Nessuno
`transform`	`Transform`
`url`	str
`urls`	elenco di str o Nessuno
`visible`	bool
`zorder`	galleggiante

Guarda anche

pcolor: Un'implementazione alternativa con caratteristiche leggermente diverse. Per una discussione dettagliata sulle differenze vedere Differenze tra pcolor() e pcolormesh() .
imshow: Se X e Y sono equidistanti, imshowpuò essere un'alternativa più veloce.

Appunti

Matrici mascherate

C può essere un array mascherato. Se è mascherato, il quadrilatero corrispondente sarà trasparente. Il mascheramento di X e Y non è supportato. Usa se hai bisogno di questa funzionalità.C[i, j]pcolor

Orientamento della griglia

L'orientamento della griglia segue la convenzione standard della matrice: un array C con forma (nrows, ncolumns) viene tracciato con il numero di colonna come X e il numero di riga come Y .

Differenze tra pcolor() e pcolormesh()

Entrambi i metodi vengono utilizzati per creare un grafico pseudocolore di una matrice 2D utilizzando quadrilateri.

La differenza principale risiede nell'oggetto creato e nella gestione interna dei dati: mentre pcolorrestituisce a PolyCollection, pcolormesh restituisce a QuadMesh. Quest'ultimo è più specializzato per lo scopo dato e quindi è più veloce. Dovrebbe essere quasi sempre preferito.

C'è anche una leggera differenza nella gestione degli array mascherati. Entrambi pcolore pcolormeshsupportano gli array mascherati per C . Tuttavia, pcolorsupporta solo array mascherati per X e Y . Il motivo risiede nella gestione interna dei valori mascherati. pcolortralascia i rispettivi poligoni dalla PolyCollection. pcolormeshimposta il colore della faccia degli elementi mascherati su trasparente. Puoi vedere la differenza quando usi edgecolors. Mentre tutti i bordi vengono disegnati indipendentemente dal mascheramento in un QuadMesh, il bordo tra due quadrilateri mascherati adiacenti pcolornon viene disegnato in quanto i poligoni corrispondenti non esistono nella PolyCollection.

Un'altra differenza è il supporto dell'ombreggiatura Gouraud in pcolormesh, che non è disponibile con pcolor.

Esempi che utilizzano `matplotlib.axes.Axes.pcolormesh`#

Demo Pcolor

pcolormesh griglie e ombreggiatura

pcolormesh

Posizionamento delle barre dei colori

Sottofigure della figura

Rasterizzazione per la grafica vettoriale

Guida al layout vincolato

Normalizzazione della mappa dei colori

pcolormesh(X, Y, Z)

matplotlib.axes.Axes.pcolormesh #

Esempi che utilizzano matplotlib.axes.Axes.pcolormesh#

Esempi che utilizzano `matplotlib.axes.Axes.pcolormesh`#