Panoramica del toolkit axisartist

Il tutorial del toolkit axisartist.

Avvertimento

axisartist utilizza una classe Axes personalizzata (derivata dalla classe Axes originale di Matplotlib). Come effetto collaterale, alcuni comandi (principalmente relativi al tick) non funzionano.

axisartist contiene una classe Axes personalizzata che ha lo scopo di supportare griglie curvilinee (ad esempio, il sistema di coordinate mondiali in astronomia). A differenza della classe Axes originale di Matplotlib che utilizza Axes.xaxis e Axes.yaxis per disegnare tick, tickline, ecc., axisartist utilizza un artista speciale (AxisArtist) in grado di gestire tick, tickline, ecc. per i sistemi di coordinate curve.

Poiché utilizza artisti speciali, alcuni comandi Matplotlib che funzionano su Axes.xaxis e Axes.yaxis potrebbero non funzionare.

artista dell'asse

Il modulo axisartist fornisce una classe Axes personalizzata (e molto sperimentale), in cui ogni asse (sinistro, destro, superiore e inferiore) ha un artista associato separato che è responsabile del disegno della linea dell'asse, dei tick, dei ticklabel e delle etichette. Puoi anche creare il tuo asse, che può passare attraverso una posizione fissa nella coordinata degli assi, o una posizione fissa nella coordinata dei dati (cioè, l'asse fluttua quando cambia viewlimit).

La classe axis, per impostazione predefinita, ha i suoi assi x e y invisibili e ha 4 artisti aggiuntivi che sono responsabili del disegno delle spine dei 4 assi in "left", "right", "bottom" e "top". Vi si accede come ax.axis["left"], ax.axis["right"], e così via, cioè, ax.axis è un dizionario che contiene artisti (si noti che ax.axis è ancora un metodo richiamabile e si comporta come un metodo Axes.axis originale in Matplotlib).

Per creare un Asse,

import mpl_toolkits.axisartist as AA
fig = plt.figure()
fig.add_axes([0.1, 0.1, 0.8, 0.8], axes_class=AA.Axes)

o per creare una sottotrama

fig.add_subplot(111, axes_class=AA.Axes)
# Given that 111 is the default, one can also do
fig.add_subplot(axes_class=AA.Axes)

Ad esempio, puoi nascondere il dorso destro e superiore utilizzando:

ax.axis["right"].set_visible(False)
ax.axis["top"].set_visible(False)

È anche possibile aggiungere un asse orizzontale. Ad esempio, potresti avere un asse orizzontale in y=0 (nella coordinata dei dati).

ax.axis["y=0"] = ax.new_floating_axis(nth_coord=0, value=0)

O un asse fisso con qualche offset

# make new (right-side) yaxis, but with some offset
ax.axis["right2"] = ax.new_fixed_axis(loc="right", offset=(20, 0))

axisartist con ParasiteAxes

La maggior parte dei comandi nel toolkit axis_grid1 può accettare un argomento della parola chiave axis_class e i comandi creano un Axes della classe data. Ad esempio, per creare una sottotrama host con axisartist.Axes,

import mpl_toolkits.axisartist as AA
from mpl_toolkits.axes_grid1 import host_subplot

host = host_subplot(111, axes_class=AA.Axes)

Ecco un esempio che utilizza ParasiteAxes.

Griglia curvilinea

La motivazione alla base del modulo AxisArtist è supportare una griglia curvilinea e tick.

Assi flottanti

AxisArtist supporta anche assi mobili i cui assi esterni sono definiti come assi mobili.

spazio dei nomi dell'artista dell'asse

Lo spazio dei nomi axisartist include un'implementazione Axes derivata. La più grande differenza è che gli artisti responsabili di disegnare la linea dell'asse, i segni di spunta, l'etichetta di spunta e le etichette degli assi sono separati dalla classe Axis di Matplotlib, che sono molto più degli artisti nella Matplotlib originale. Questo cambiamento è stato fortemente motivato a supportare la griglia curvilinea. Ecco alcune cose che mpl_toolkits.axisartist.Axes è diverso dagli assi originali di Matplotlib.

• Gli elementi dell'asse (linea dell'asse (colonna vertebrale), tick, ticklabel ed etichette dell'asse) sono disegnati da un'istanza AxisArtist. A differenza di Axis, gli assi sinistro, destro, superiore e inferiore sono disegnati da artisti separati. E ognuno di essi può avere una posizione di spunta diversa e etichette di spunta diverse.

• le linee della griglia vengono disegnate da un'istanza Gridlines. Il cambiamento è stato motivato dal fatto che in coordinate curvilinee, una linea della griglia non può attraversare le linee dell'asse (cioè, nessun segno di spunta associato). Nella classe Axes originale, le griglie sono legate ai tick.

• le linee di graduazione possono essere ruotate se necessario (ad esempio, lungo le linee della griglia)

In sintesi, tutti questi cambiamenti dovevano supportare

• una griglia curvilinea.

• un asse mobile

La classe mpl_toolkits.axisartist.Axes definisce un attributo axis , che è un dizionario di istanze AxisArtist. Per impostazione predefinita, il dizionario ha 4 istanze AxisArtist, responsabili del disegno dell'asse sinistro, destro, inferiore e superiore.

Gli attributi xaxis e yaxis sono ancora disponibili, tuttavia sono impostati su non visibili. Poiché vengono utilizzati artisti separati per il rendering dell'asse, alcuni metodi relativi all'asse in Matplotlib potrebbero non avere alcun effetto. Oltre alle istanze AxisArtist, mpl_toolkits.axisartist.Axes avrà l' attributo gridlines (Gridlines), che ovviamente disegna le linee della griglia.

Sia in AxisArtist che in Gridlines, il calcolo del tick e della posizione della griglia è delegato a un'istanza della classe GridHelper. La classe mpl_toolkits.axisartist.Axes utilizza GridHelperRectlinear come helper della griglia. La classe GridHelperRectlinear è un wrapper attorno all'asse x e all'asse y degli assi originali di Matplotlib , e doveva funzionare come il modo in cui funzionano gli assi originali di Matplotlib. Ad esempio, le modifiche alla posizione del segno di spunta utilizzando il metodo set_ticks e così via dovrebbero funzionare come previsto. Ma il cambiamento nelle proprietà dell'artista (ad esempio, il colore) non funzionerà in generale, sebbene sia stato fatto uno sforzo per rispettare alcuni attributi che cambiano spesso (colore, ecc.).

AxisArtista

AxisArtist può essere considerato un artista contenitore con i seguenti attributi che disegneranno segni di spunta, etichette, ecc.

• linea

• major_ticks, major_ticklabels

• minor_tick, minor_ticklabels

• offsetTesto

• etichetta

linea

Derivato dalla classe Line2D. Responsabile del disegno di una linea spinale (?).

tick_maggiori, tick_minori

Derivato dalla classe Line2D. Si noti che le zecche sono indicatori.

major_ticklabels, minor_ticklabels

Derivato dal testo. Si noti che non si tratta di un elenco di artisti del testo, ma di un singolo artista (simile a una raccolta).

etichetta dell'asse

Derivato dal testo.

Predefinito AxisArtists

Per impostazione predefinita, sono definiti i seguenti artisti dell'asse:

ax.axis["left"], ax.axis["bottom"], ax.axis["right"], ax.axis["top"]

I ticklabel e l'axislabel dell'asse superiore e destro sono impostati su non visibili.

Ad esempio, se desideri modificare gli attributi del colore di major_ticklabels dell'asse x inferiore

ax.axis["bottom"].major_ticklabels.set_color("b")

Allo stesso modo, per rendere invisibili le ticklabel

ax.axis["bottom"].major_ticklabels.set_visible(False)

AxisArtist fornisce un metodo di supporto per controllare la visibilità di tick, ticklabel ed etichetta. Per rendere invisibile il ticklabel,

ax.axis["bottom"].toggle(ticklabels=False)

Per rendere invisibili tutti i segni di spunta, le etichette di spunta e l'etichetta (asse).

ax.axis["bottom"].toggle(all=False)

Per disattivare tutto tranne le zecche

ax.axis["bottom"].toggle(all=False, ticks=True)

Per attivare tutto tranne l'etichetta (asse) disattivata

ax.axis["bottom"].toggle(all=True, label=False)

Il metodo __getitem__ di ax.axis può accettare più nomi di assi. Ad esempio, per attivare le etichette di spunta dell'asse "superiore" e "destra",

ax.axis["top", "right"].toggle(ticklabels=True)

Nota che restituisce un semplice oggetto proxy che traduce il codice sopra in qualcosa come sotto.ax.axis["top", "right"]

for n in ["top", "right"]:
    ax.axis[n].toggle(ticklabels=True)

Pertanto, qualsiasi valore restituito nel ciclo for viene ignorato. E non dovresti usarlo nient'altro che un semplice metodo.

Come l'indicizzazione dell'elenco ":" indica tutti gli elementi, ad es.

ax.axis[:].major_ticks.set_color("r")

cambia il colore del segno di spunta su tutti gli assi.

Come

1. Modifica delle posizioni e dell'etichetta delle zecche.

Come gli assi originali di Matplotlib:

ax.set_xticks([1, 2, 3])

2. Modifica delle proprietà degli assi come il colore, ecc.

Modificare le proprietà degli artisti appropriati. Ad esempio, per cambiare il colore delle etichette di spunta:

ax.axis["left"].major_ticklabels.set_color("r")

3. Per modificare gli attributi di più assi:

   ax.axis["left", "bottom"].major_ticklabels.set_color("r")
   

   o per modificare gli attributi di tutti gli assi:

   ax.axis[:].major_ticklabels.set_color("r")
   

4. Per modificare la dimensione del tick (lunghezza), è necessario utilizzare il metodo axis.major_ticks.set_ticksize. Per modificare la direzione dei segni di spunta (i segni di spunta sono nella direzione opposta rispetto alle ticklabel per impostazione predefinita), utilizzare il metodo axis.major_ticks.set_tick_out.

   Per cambiare il pad tra tick e ticklabels, usa il metodo axis.major_ticklabels.set_pad.

   Per cambiare il pad tra etichette di spunta e etichetta dell'asse, metodo axis.label.set_pad.

Rotazione e allineamento delle TickLabel

Anche questo è abbastanza diverso da Matplotlib standard e può creare confusione. Quando si desidera ruotare le etichette di spunta, considerare innanzitutto l'utilizzo del metodo "set_axis_direction".

ax1.axis["left"].major_ticklabels.set_axis_direction("top")
ax1.axis["right"].label.set_axis_direction("left")

Il parametro per set_axis_direction è uno tra ["left", "right", "bottom", "top"].

È necessario comprendere alcuni concetti di base delle direzioni.

• Esiste una direzione di riferimento definita come la direzione della linea dell'asse con coordinate crescenti. Ad esempio, la direzione di riferimento dell'asse x sinistro è dal basso verso l'alto.

  La direzione, l'angolo del testo e gli allineamenti dei tick, dei ticklabel e dell'asse-etichetta sono determinati rispetto alla direzione di riferimento

• label_direction e ticklabel_direction sono il lato destro (+) della direzione di riferimento o il lato sinistro (-).

• i segni di spunta sono disegnati per impostazione predefinita nella direzione opposta delle etichette di spunta.

• la rotazione del testo di ticklabels e label è determinata rispettivamente in riferimento a ticklabel_direction o label_direction . La rotazione delle etichette e dell'etichetta è ancorata.

D'altra parte, esiste un concetto di "asse_direzione". Questa è un'impostazione predefinita delle proprietà precedenti per ogni asse "in basso", "a sinistra", "in alto" e "a destra".

?	?	sinistra	parte inferiore	Giusto	superiore
etichetta dell'asse	direzione	'-'	'+'	'+'	'-'
etichetta dell'asse	rotazione	180	0	0	180
etichetta dell'asse	Va	centro	superiore	centro	parte inferiore
etichetta dell'asse	ah	Giusto	centro	Giusto	centro
ticklabel	direzione	'-'	'+'	'+'	'-'
ticklabels	rotazione	90	0	-90	180
ticklabel	ah	Giusto	centro	Giusto	centro
ticklabel	Va	centro	linea di base	centro	linea di base

E, 'set_axis_direction("top")' significa regolare la rotazione del testo ecc., per impostazioni adatte all'asse "top". Il concetto di direzione dell'asse può essere più chiaro con l'asse curvo.

axis_direction può essere regolato nel livello AxisArtist o nel livello dei suoi artisti figli, ad esempio tick, ticklabel e axis-label.

ax1.axis["left"].set_axis_direction("top")

cambia axis_direction di tutti gli artisti associati con l'asse "sinistra", mentre

ax1.axis["left"].major_ticklabels.set_axis_direction("top")

cambia l'axis_direction solo delle major_ticklabels. Si noti che set_axis_direction nel livello AxisArtist modifica ticklabel_direction e label_direction, mentre la modifica di axis_direction di tick, ticklabel e axis-label non li influenza.

Se vuoi creare tick verso l'esterno e ticklabel all'interno degli assi, usa il metodo invert_ticklabel_direction.

ax.axis[:].invert_ticklabel_direction()

Un metodo correlato è "set_tick_out". Fa tick verso l'esterno (in effetti, fa tick verso la direzione opposta alla direzione predefinita).

ax.axis[:].major_ticks.set_tick_out(True)

Quindi, riassumendo,

• I metodi di AxisArtist

  • set_axis_direction: "sinistra", "destra", "basso" o "alto"

  • set_ticklabel_direction: "+" o "-"

  • set_axislabel_direction: "+" o "-"

  • invert_ticklabel_direction

• Metodi delle zecche (major_ticks e minor_ticks)

  • set_tick_out: vero o falso

  • set_ticksize: dimensione in punti

• Metodi di TickLabels (major_ticklabels e minor_ticklabels)

  • set_axis_direction: "sinistra", "destra", "basso" o "alto"

  • set_rotation: angolo rispetto alla direzione di riferimento

  • set_ha e set_va: vedi sotto

• Metodi di AxisLabels (etichetta)

  • set_axis_direction: "sinistra", "destra", "basso" o "alto"

  • set_rotation: angolo rispetto alla direzione di riferimento

  • set_ha e set_va

Regolazione dell'allineamento delle etichette di spunta

L'allineamento di TickLabels è trattato in modo speciale. Vedi sotto

Tampone di regolazione

Per cambiare il pad tra tick e ticklabel

ax.axis["left"].major_ticklabels.set_pad(10)

O ticklabels e axis-label

ax.axis["left"].label.set_pad(10)

GridHelper

Per definire effettivamente una coordinata curvilinea, devi usare il tuo aiuto griglia. Viene fornita una versione generalizzata della classe grid helper e questa classe dovrebbe essere sufficiente nella maggior parte dei casi. Un utente può fornire due funzioni che definiscono una trasformazione (e la sua coppia inversa) dalla coordinata curva alla coordinata immagine (rettilinea). Si noti che mentre i tick e le griglie sono disegnati per coordinate curve, la trasformazione dei dati degli assi stessi (ax.transData) è ancora coordinata rettilinea (immagine).

from mpl_toolkits.axisartist.grid_helper_curvelinear \
     import GridHelperCurveLinear
from mpl_toolkits.axisartist import Axes

# from curved coordinate to rectlinear coordinate.
def tr(x, y):
    x, y = np.asarray(x), np.asarray(y)
    return x, y-x

# from rectlinear coordinate to curved coordinate.
def inv_tr(x, y):
    x, y = np.asarray(x), np.asarray(y)
    return x, y+x

grid_helper = GridHelperCurveLinear((tr, inv_tr))

fig.add_subplot(axes_class=Axes, grid_helper=grid_helper)

È invece possibile utilizzare l'istanza Transform di Matplotlib (ma è necessario definire una trasformazione inversa). Spesso, l'intervallo di coordinate in un sistema di coordinate curvo può avere un intervallo limitato o può avere cicli. In questi casi, è necessaria una versione più personalizzata di grid helper.

import mpl_toolkits.axisartist.angle_helper as angle_helper

# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()

# extreme finder: find a range of coordinate.
# 20, 20: number of sampling points along x, y direction
# The first coordinate (longitude, but theta in polar)
#   has a cycle of 360 degree.
# The second coordinate (latitude, but radius in polar)  has a minimum of 0
extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
                                                 lon_cycle = 360,
                                                 lat_cycle = None,
                                                 lon_minmax = None,
                                                 lat_minmax = (0, np.inf),
                                                 )

# Find a grid values appropriate for the coordinate (degree,
# minute, second). The argument is a approximate number of grids.
grid_locator1 = angle_helper.LocatorDMS(12)

# And also uses an appropriate formatter.  Note that the acceptable Locator
# and Formatter classes are different than that of Matplotlib's, and you
# cannot directly use Matplotlib's Locator and Formatter here (but may be
# possible in the future).
tick_formatter1 = angle_helper.FormatterDMS()

grid_helper = GridHelperCurveLinear(tr,
                                    extreme_finder=extreme_finder,
                                    grid_locator1=grid_locator1,
                                    tick_formatter1=tick_formatter1
                                    )

Ancora una volta, il transData degli assi è ancora una coordinata rettilinea (coordinata dell'immagine). Puoi eseguire manualmente la conversione tra due coordinate oppure puoi utilizzare Parasite Axes per comodità:

ax1 = SubplotHost(fig, 1, 2, 2, grid_helper=grid_helper)

# A parasite axes with given transform
ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
# note that ax2.transData == tr + ax1.transData
# Anything you draw in ax2 will match the ticks and grids of ax1.
ax1.parasites.append(ax2)

Asse mobile

Un asse mobile è un asse la cui coordinata dei dati è fissa, ovvero la sua posizione non è fissa nelle coordinate degli assi ma cambia al variare dei limiti dei dati degli assi. È possibile creare un asse mobile utilizzando il metodo new_floating_axis . Tuttavia, è tua responsabilità che l'AxisArtist risultante venga aggiunto correttamente agli assi. Un modo consigliato è aggiungerlo come elemento dell'attributo axis di Axes.:

# floating axis whose first (index starts from 0) coordinate
# (theta) is fixed at 60

ax1.axis["lat"] = axis = ax1.new_floating_axis(0, 60)
axis.label.set_text(r"$\theta = 60^{\circ}$")
axis.label.set_visible(True)

Vedi il primo esempio di questa pagina.

Limiti attuali e TODO

Il codice ha bisogno di più raffinatezza. Ecco un elenco incompleto di problemi e cose da fare

• Nessun modo semplice per supportare una posizione di spunta personalizzata dall'utente (per griglia curvilinea). È necessario creare una nuova classe Locator.

• FloatingAxis può avere limiti di coordinate, ad esempio un asse mobile di x = 0, ma y si estende solo da 0 a 1.

• La posizione dell'etichetta dell'asse di FloatingAxis deve essere facoltativamente fornita come valore di coordinata. ex, un asse mobile di x=0 con etichetta in y=1