Panoramica di mpl_toolkits.axes_grid1

axes_grid1fornisce le seguenti caratteristiche:

• Classi helper ( ImageGrid , RGBAxes , AxesDivider ) per facilitare il layout degli assi che visualizzano immagini con proporzioni fisse soddisfacendo al contempo vincoli aggiuntivi (corrispondenza delle altezze di una barra dei colori e di un'immagine o correzione del riempimento tra le immagini);

• ParasiteAxes (caratteristiche simili a twinx/twiny in modo da poter tracciare dati diversi (ad esempio, diversa scala y) in uno stesso Axes);

• AnchoredArtists (artisti personalizzati posizionati in una posizione ancorata, in modo simile alle leggende).

assi_griglia1

ImmagineGriglia

In Matplotlib, la posizione e la dimensione degli assi sono generalmente specificate in coordinate di figure normalizzate (0 = in basso a sinistra, 1 = in alto a destra), il che rende difficile ottenere un riempimento fisso (assoluto) tra le immagini. ImageGridpuò essere utilizzato per ottenere tale imbottitura; vedere i suoi documenti per informazioni dettagliate sull'API.

• La posizione di ogni asse è determinata al momento del disegno (vedi AxesDivider ), in modo che la dimensione dell'intera griglia rientri nel rettangolo dato (come l'aspetto degli assi). Si noti che in questo esempio le spaziature tra gli assi sono fisse anche se si modifica la dimensione della figura.

• Gli assi nella stessa colonna condividono il loro asse x e gli assi nella stessa riga condividono il loro asse y (nel senso di sharex, sharey). Inoltre, gli assi nella stessa colonna hanno tutti la stessa larghezza e gli assi nella stessa riga hanno tutti la stessa altezza. Queste larghezze e altezze vengono ridimensionate in proporzione ai limiti di visualizzazione degli assi (xlim o ylim).

  

Gli esempi seguenti mostrano cosa puoi fare con ImageGrid.

Classe AxesDivider

Dietro le quinte, ImageGrid (e RGBAxes, descritti di seguito) si affidano a AxesDivider, il cui ruolo è calcolare la posizione degli assi al momento del disegno.

Gli utenti in genere non hanno bisogno di istanziare direttamente i divisori chiamando AxesDivider; invece, make_axes_locatablepuò essere utilizzato per creare un divisore per un Asse:

ax = subplot(1, 1, 1)
divider = make_axes_locatable(ax)

AxesDivider.append_axespuò quindi essere utilizzato per creare nuovi assi su un dato lato ("sinistra", "destra", "superiore", "inferiore") degli assi originali.

barra dei colori la cui altezza (o larghezza) è sincronizzata con gli assi principali

scatter_hist.py con AxesDivider

L' esempio di grafico a dispersione con istogrammi può essere riscritto utilizzando make_axes_locatable:

axScatter = plt.subplot()
axScatter.scatter(x, y)
axScatter.set_aspect(1.)

# create new axes on the right and on the top of the current axes.
divider = make_axes_locatable(axScatter)
axHistx = divider.append_axes("top", size=1.2, pad=0.1, sharex=axScatter)
axHisty = divider.append_axes("right", size=1.2, pad=0.1, sharey=axScatter)

# the scatter plot:
# histograms
bins = np.arange(-lim, lim + binwidth, binwidth)
axHistx.hist(x, bins=bins)
axHisty.hist(y, bins=bins, orientation='horizontal')

Vedi il codice sorgente completo di seguito.

L' istogramma a dispersione (assi individuabili) che utilizza AxesDivider presenta alcuni vantaggi rispetto al grafico a dispersione originale con istogrammi in Matplotlib. Ad esempio, è possibile impostare le proporzioni del grafico a dispersione, anche con l'asse x o l'asse y condiviso di conseguenza.

Assi parassita

Il ParasiteAxes è un Axes la cui posizione è identica ai suoi assi host. La posizione viene regolata durante il disegno, quindi funziona anche se l'host cambia la sua posizione (ad esempio, immagini).

Nella maggior parte dei casi, prima crei un host axis, che fornisce alcuni metodi che possono essere usati per creare assi parassiti. Sono twinx, twiny(che sono simili a twinxe twinynel matplotlib) e twin. twinaccetta una trasformazione arbitraria che mappa tra le coordinate dei dati degli assi host e gli assi parassiti. Ildraw metodo degli assi parassiti non vengono mai chiamati. Invece, host axis raccoglie gli artisti negli assi parassita e li disegna come se appartenessero agli assi host, cioè, gli artisti negli assi parassita vengono uniti a quelli degli assi host e quindi disegnati secondo il loro zorder. Gli assi ospite e parassita modificano parte del comportamento degli assi. Ad esempio, il ciclo di colori per le linee della trama è condiviso tra host e parassiti. Inoltre, il comando legend in host crea una legenda che include linee negli assi del parassita. Per creare un asse host, puoi usare host_subploto host_axescomando.

Esempio 1. twinx

Esempio 2. gemello

twinsenza un argomento di trasformazione presuppone che gli assi del parassita abbiano la stessa trasformazione di dati dell'host. Ciò può essere utile quando si desidera che l'asse superiore (o destro) abbia diverse posizioni di tick, etichette di tick o formattatore di tick per l'asse inferiore (o sinistro).

ax2 = ax.twin() # now, ax2 is responsible for "top" axis and "right" axis
ax2.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi],
               labels=["0", r"$\frac{1}{2}\pi$",
                       r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])

Un esempio più sofisticato usando twin. Si noti che se si modifica il limite x negli assi host, il limite x degli assi parassita cambierà di conseguenza.

Artisti ancorati

axes_grid1.anchored_artistsè una raccolta di artisti la cui collocazione è ancorata alla (axes) bbox, analogamente alle leggende. Questi artisti derivano da offsetbox.OffsetBox, e l'artista deve essere disegnato nelle coordinate della tela. È disponibile un supporto limitato per le trasformazioni arbitrarie. Ad esempio, l'ellisse nell'esempio seguente avrà larghezza e altezza nelle coordinate dei dati.

InsetLocator

Guarda anche

Axes.inset_axese Axes.indicate_inset_zoomnella biblioteca principale.

axes_grid1.inset_locatorfornisce classi e funzioni helper per posizionare gli assi interni in una posizione ancorata degli assi padre, analogamente a AnchoredArtist.

inset_locator.inset_axescrea un asse interno la cui dimensione è fissa o una proporzione fissa degli assi principali:

inset_axes = inset_axes(parent_axes,
                        width="30%",  # width = 30% of parent_bbox
                        height=1.,  # height = 1 inch
                        loc='lower left')

crea un asse interno la cui larghezza è il 30% degli assi padre e la cui altezza è fissata a 1 pollice.

inset_locator.zoomed_inset_axescrea un asse interno la cui scala dei dati è quella degli assi padre moltiplicata per un fattore, ad es

inset_axes = zoomed_inset_axes(ax,
                               0.5,  # zoom = 0.5
                               loc='upper right')

crea un asse interno la cui scala dei dati è la metà degli assi padre. Questo può essere utile per contrassegnare l'area ingrandita sugli assi principali:

inset_locator.mark_insetconsente di contrassegnare la posizione dell'area rappresentata dagli assi inseriti:

Assi RGB

RGBAxes è una classe helper per mostrare comodamente immagini composite RGB. Come ImageGrid, la posizione degli assi viene regolata in modo che l'area da essi occupata rientri in un dato rettangolo. Inoltre, l'asse x e l'asse y di ogni asse sono condivisi.

from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes

fig = plt.figure()
ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0)
r, g, b = get_rgb()  # r, g, b are 2D images.
ax.imshow_rgb(r, g, b)

AssiDivisore

Il mpl_toolkits.axes_grid1.axes_dividermodulo fornisce classi di supporto per regolare le posizioni degli assi di un insieme di immagini al momento del disegno.

• axes_sizefornisce una classe di unità utilizzate per determinare la dimensione di ogni asse. Ad esempio, puoi specificare una dimensione fissa.

• Dividerè la classe che calcola la posizione degli assi. Divide l'area rettangolare data in diverse aree. Il divisore viene inizializzato impostando gli elenchi delle dimensioni orizzontali e verticali su cui si baserà la divisione. Quindi utilizzare new_locator(), che restituisce un oggetto richiamabile che può essere utilizzato per impostare axis_locator degli assi.

Qui dimostriamo come ottenere il seguente layout: vogliamo posizionare gli assi in una griglia 3x4 (nota che Dividerfa partire gli indici di riga dal fondo (!) della griglia):

+--------+--------+--------+--------+
| (2, 0) | (2, 1) | (2, 2) | (2, 3) |
+--------+--------+--------+--------+
| (1, 0) | (1, 1) | (1, 2) | (1, 3) |
+--------+--------+--------+--------+
| (0, 0) | (0, 1) | (0, 2) | (0, 3) |
+--------+--------+--------+--------+

in modo tale che la fila inferiore abbia un'altezza fissa di 2 (pollici) e le due file superiori abbiano un rapporto di altezza compreso tra 2 (centrale) e 3 (superiore). (Ad esempio, se la griglia ha una dimensione di 7 pollici, la riga inferiore sarà di 2 pollici, anche la riga centrale di 2 pollici e la riga superiore di 3 pollici.)

Questi vincoli sono specificati utilizzando le classi del axes_sizemodulo, vale a dire:

from mpl_toolkits.axes_grid1.axes_size import Fixed, Scaled
vert = [Fixed(2), Scaled(2), Scaled(3)]

(Più in generale, axes_sizele classi definiscono un get_size(renderer)metodo che restituisce una coppia di float: una dimensione relativa e una dimensione assoluta. Fixed(2).get_size(renderer)return ; return .)(0, 2)Scaled(2).get_size(renderer)(2, 0)

Usiamo questi vincoli per inizializzare un Divideroggetto:

rect = [0.2, 0.2, 0.6, 0.6]  # Position of the grid in the figure.
vert = [Fixed(2), Scaled(2), Scaled(3)]  # As above.
horiz = [...]  # Some other horizontal constraints.
divider = Divider(fig, rect, horiz, vert)

quindi utilizzare Divider.new_locatorper creare AxesLocatorun'istanza per una data voce di griglia:

locator = divider.new_locator(nx=0, ny=1)  # Grid entry (1, 0).

e renderlo responsabile della localizzazione degli assi:

ax.set_axes_locator(locator)

AxesLocatorè un oggetto richiamabile che restituisce la posizione e la dimensione della cella nella prima colonna e nella seconda riga .

I localizzatori che si estendono su più celle possono essere creati con, ad esempio:

# Columns #0 and #1 ("0-2 range"), row #1.
locator = divider.new_locator(nx=0, nx1=2, ny=1)

Guarda l'esempio,

È inoltre possibile regolare la dimensione di ciascun asse in base ai relativi limiti di dati x o y (AxesX e AxesY).