Visão geral do kit de ferramentas axisartist

O tutorial do kit de ferramentas axisartist.

Aviso

axisartist usa uma classe Axes personalizada (derivada da classe Axes original do Matplotlib). Como efeito colateral, alguns comandos (principalmente relacionados a ticks) não funcionam.

O axisartist contém uma classe Axes personalizada que se destina a suportar grades curvilíneas (por exemplo, o sistema de coordenadas mundiais em astronomia). Ao contrário da classe Axes original do Matplotlib, que usa Axes.xaxis e Axes.yaxis para desenhar marcações, linhas de marcação, etc., axisartist usa um artista especial (AxisArtist) que pode manipular marcações, linhas de marcação etc. para sistemas de coordenadas curvas.

Como ele usa artistas especiais, alguns comandos do Matplotlib que funcionam em Axes.xaxis e Axes.yaxis podem não funcionar.

artista do eixo

O módulo axisartist fornece uma classe Axes personalizada (e muito experimental), onde cada eixo (esquerda, direita, superior e inferior) tem um artista associado separado que é responsável por desenhar a linha do eixo, ticks, ticklabels e labels. Você também pode criar seu próprio eixo, que pode passar por uma posição fixa na coordenada de eixos ou uma posição fixa na coordenada de dados (ou seja, o eixo flutua quando o viewlimit muda).

A classe axes, por padrão, tem seu xaxis e yaxis invisíveis, e possui 4 artistas adicionais que são responsáveis ​​por desenhar as 4 colunas do eixo em "esquerda", "direita", "inferior" e "superior". Eles são acessados ​​como ax.axis["esquerda"], ax.axis["direita"] e assim por diante, ou seja, ax.axis é um dicionário que contém artistas (observe que ax.axis ainda é um método que pode ser chamado e se comporta como um método Axes.axis original no Matplotlib).

Para criar um eixo,

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

ou para criar uma subtrama

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)

Por exemplo, você pode ocultar as lombadas direita e superior usando:

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

Também é possível adicionar um eixo horizontal. Por exemplo, você pode ter um eixo horizontal em y=0 (na coordenada de dados).

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

Ou um eixo fixo com algum deslocamento

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

axisartist com ParasiteAxes

A maioria dos comandos no kit de ferramentas axes_grid1 pode receber um argumento de palavra-chave axes_class e os comandos criam um Axes da classe fornecida. Por exemplo, para criar uma subtrama de host com axisartist.Axes,

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

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

Aqui está um exemplo que usa ParasiteAxes.

Grade curvilínea

A motivação por trás do módulo AxisArtist é suportar uma grade curvilínea e carrapatos.

Eixos Flutuantes

AxisArtist também oferece suporte a eixos flutuantes cujos eixos externos são definidos como eixos flutuantes.

namespace axisartist

O namespace axisartist inclui uma implementação derivada de Axes. A maior diferença é que os artistas responsáveis ​​por desenhar linha de eixo, ticks, ticklabel e etiquetas de eixo são separados da classe Axis do Matplotlib, que são muito mais do que artistas no Matplotlib original. Essa mudança foi fortemente motivada para suportar a grade curvilínea. Aqui estão algumas coisas que mpl_toolkits.axisartist.Axes é diferente dos Axes originais do Matplotlib.

• Elementos de eixo (linha de eixo (espinha), carrapatos, rótulo de marcação e rótulos de eixo) são desenhados por uma instância de AxisArtist. Ao contrário do Axis, os eixos esquerdo, direito, superior e inferior são desenhados por artistas separados. E cada um deles pode ter uma localização de tick diferente e rótulos de tick diferentes.

• linhas de grade são desenhadas por uma instância Gridlines. A mudança foi motivada pelo fato de que, em coordenadas curvilíneas, uma linha de grade não pode cruzar linhas de eixo (ou seja, sem marcações associadas). Na classe Axes original, as linhas de grade estão vinculadas aos ticks.

• as linhas de marcação podem ser giradas, se necessário (ou seja, ao longo das linhas de grade)

Em resumo, todas essas mudanças foram para suportar

• uma grade curvilínea.

• um eixo flutuante

A classe mpl_toolkits.axisartist.Axes define um atributo de eixo , que é um dicionário de instâncias de AxisArtist. Por padrão, o dicionário possui 4 instâncias de AxisArtist, responsáveis ​​pelo desenho dos eixos esquerdo, direito, inferior e superior.

Os atributos xaxis e yaxis ainda estão disponíveis, mas estão definidos como não visíveis. Como artistas separados são usados ​​para renderizar o eixo, algum método relacionado ao eixo no Matplotlib pode não ter efeito. Além das instâncias de AxisArtist, o mpl_toolkits.axisartist.Axes terá o atributo gridlines (Gridlines), que obviamente desenha linhas de grade.

Tanto no AxisArtist quanto no Gridlines, o cálculo do tick e da localização da grade é delegado a uma instância da classe GridHelper. A classe mpl_toolkits.axisartist.Axes usa GridHelperRectlinear como um auxiliar de grade. A classe GridHelperRectlinear é um wrapper em torno dos eixos xaxis e yaxis dos eixos originais do Matplotlib, e foi criada para funcionar da mesma forma que os eixos originais do Matplotlib funcionam. Por exemplo, as alterações de localização de marcação usando o método set_ticks e etc. devem funcionar conforme o esperado. Mas a mudança nas propriedades do artista (por exemplo, cor) não funcionará em geral, embora algum esforço tenha sido feito para que alguns atributos frequentemente alterados (cor, etc.) sejam respeitados.

AxisArtist

AxisArtist pode ser considerado como um artista de container com os seguintes atributos que irão desenhar ticks, labels, etc.

• linha

• major_ticks, major_ticklabels

• minor_ticks, minor_ticklabels

• offsetText

• etiqueta

linha

Derivado da classe Line2D. Responsável por desenhar uma linha espinhal (?).

major_ticks, minor_ticks

Derivado da classe Line2D. Observe que os carrapatos são marcadores.

major_ticklabels, minor_ticklabels

Derivado do Texto. Observe que não é uma lista de artistas de texto, mas um único artista (semelhante a uma coleção).

axislabel

Derivado do Texto.

AxisArtists padrão

Por padrão, os seguintes artistas de eixo são definidos.:

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

Os ticklabels e axislabel do eixo superior e direito são definidos como não visíveis.

Por exemplo, se você quiser alterar os atributos de cor de major_ticklabels do eixo x inferior

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

Da mesma forma, para tornar os marcadores invisíveis

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

AxisArtist fornece um método auxiliar para controlar a visibilidade de marcas, rótulos de marca e rótulo. Para tornar o marcador invisível,

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

Para tornar todos os ticks, ticklabels e (eixo) label invisíveis

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

Para desligar tudo, mas ligar

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

Para ativar tudo, exceto o rótulo (eixo) desativado

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

O método __getitem__ de ax.axis pode receber vários nomes de eixo. Por exemplo, para ativar os marcadores dos eixos "superior" e "direito",

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

Observe que retorna um objeto proxy simples que traduz o código acima para algo como abaixo.ax.axis["top", "right"]

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

Portanto, quaisquer valores de retorno no loop for são ignorados. E você não deve usar nada além de um método simples.

Como a indexação da lista ":" significa todos os itens, ou seja,

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

altera a cor do tick em todos os eixos.

Como fazer

1. Alterando os locais e o rótulo dos carrapatos.

Igual aos eixos originais do Matplotlib:

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

2. Alterar as propriedades do eixo, como cor, etc.

Altere as propriedades dos artistas apropriados. Por exemplo, para alterar a cor dos ticklabels:

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

3. Para alterar os atributos de eixo múltiplo:

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

   ou para alterar os atributos de todos os eixos:

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

4. Para alterar o tamanho do tick (comprimento), você precisa usar o método axis.major_ticks.set_ticksize. Para alterar a direção dos ticks (os ticks estão na direção oposta dos ticklabels por padrão), use o método axis.major_ticks.set_tick_out.

   Para alterar o pad entre ticks e ticklabels, use o método axis.major_ticklabels.set_pad.

   Para alterar o pad entre os marcadores e o rótulo do eixo, use o método axis.label.set_pad.

Rotação e Alinhamento de TickLabels

Isso também é bem diferente do Matplotlib padrão e pode ser confuso. Quando você quiser girar os ticklabels, primeiro considere usar o método "set_axis_direction".

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

O parâmetro para set_axis_direction é um dos ["left", "right", "bottom", "top"].

Você deve entender algum conceito subjacente de direções.

• Existe uma direção de referência que é definida como a direção da linha do eixo com coordenada crescente. Por exemplo, a direção de referência do eixo x esquerdo é de baixo para cima.

  A direção, o ângulo do texto e os alinhamentos dos ticks, ticklabels e axis-label são determinados em relação à direção de referência

• label_direction e ticklabel_direction são o lado direito (+) da direção de referência ou o lado esquerdo (-).

• os ticks são, por padrão, desenhados na direção oposta dos ticklabels.

• a rotação de texto de ticklabels e label é determinada em referência a ticklabel_direction ou label_direction , respectivamente. A rotação de ticklabels e label é ancorada.

Por outro lado, existe um conceito de "axis_direction". Esta é uma configuração padrão das propriedades acima para cada eixo "inferior", "esquerdo", "superior" e "direito".

?	?	deixei	fundo	certo	topo
rótulo do eixo	direção	'-'	'+'	'+'	'-'
rótulo do eixo	rotação	180	0	0	180
rótulo do eixo	va	Centro	topo	Centro	fundo
rótulo do eixo	ha	certo	Centro	certo	Centro
marca de seleção	direção	'-'	'+'	'+'	'-'
marcadores	rotação	90	0	-90	180
marca de seleção	ha	certo	Centro	certo	Centro
marca de seleção	va	Centro	linha de base	Centro	linha de base

E, 'set_axis_direction("top")' significa ajustar a rotação do texto, etc, para configurações adequadas para o eixo "top". O conceito de direção do eixo pode ser mais claro com o eixo curvo.

A axis_direction pode ser ajustada no nível AxisArtist, ou no nível de seus artistas filhos, ou seja, ticks, ticklabels e axis-label.

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

muda axis_direction de todos os artistas associados com o eixo "esquerdo", enquanto

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

altera a axis_direction apenas dos major_ticklabels. Observe que set_axis_direction no nível AxisArtist altera ticklabel_direction e label_direction, enquanto alterar a axis_direction de ticks, ticklabels e axis-label não os afeta.

Se você quiser fazer marcações para fora e marcações dentro dos eixos, use o método invert_ticklabel_direction.

ax.axis[:].invert_ticklabel_direction()

Um método relacionado é "set_tick_out". Ele faz tiques para fora (na verdade, faz tiques na direção oposta à direção padrão).

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

Assim, em resumo,

• Métodos do AxisArtist

  • set_axis_direction: "esquerda", "direita", "inferior" ou "superior"

  • set_ticklabel_direction: "+" ou "-"

  • set_axislabel_direction: "+" ou "-"

  • invert_ticklabel_direction

• Métodos dos ticks (major_ticks e minor_ticks)

  • set_tick_out: Verdadeiro ou Falso

  • set_ticksize: tamanho em pontos

• Métodos TickLabels (major_ticklabels e minor_ticklabels)

  • set_axis_direction: "esquerda", "direita", "inferior" ou "superior"

  • set_rotation: ângulo em relação à direção de referência

  • set_ha e set_va: veja abaixo

• Métodos de AxisLabels (rótulo)

  • set_axis_direction: "esquerda", "direita", "inferior" ou "superior"

  • set_rotation: ângulo em relação à direção de referência

  • set_ha e set_va

Ajustando o alinhamento dos marcadores

O alinhamento de TickLabels é tratado de forma especial. Veja abaixo

Almofada de ajuste

Para alterar o pad entre ticks e ticklabels

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

Ou ticklabels e axis-label

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

GridHelper

Para realmente definir uma coordenada curvilínea, você deve usar seu próprio auxiliar de grade. Uma versão generalizada da classe auxiliar de grade é fornecida e esta classe deve ser suficiente na maioria dos casos. Um usuário pode fornecer duas funções que definem uma transformação (e seu par inverso) da coordenada curva para a coordenada da imagem (retilínea). Observe que, embora os ticks e as grades sejam desenhados para coordenadas curvas, a transformação de dados dos próprios eixos (ax.transData) ainda é uma coordenada retilínea (imagem).

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)

Você pode usar a instância Transform do Matplotlib (mas uma transformação inversa deve ser definida). Freqüentemente, o intervalo de coordenadas em um sistema de coordenadas curvo pode ter um intervalo limitado ou pode ter ciclos. Nesses casos, é necessária uma versão mais personalizada do auxiliar de grade.

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
                                    )

Novamente, o transData dos eixos ainda é uma coordenada retilínea (coordenada de imagem). Você pode fazer a conversão manualmente entre duas coordenadas ou pode usar os eixos parasitas por conveniência.:

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)

FloatingAxis

Um eixo flutuante é um eixo cuja coordenada de dados é fixa, ou seja, sua localização não é fixa na coordenada dos eixos, mas muda conforme os limites de dados dos eixos mudam. Um eixo flutuante pode ser criado usando o método new_floating_axis . No entanto, é sua responsabilidade que o AxisArtist resultante seja adicionado adequadamente aos eixos. Uma maneira recomendada é adicioná-lo como um item do atributo axis de 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)

Veja o primeiro exemplo desta página.

Limitações Atuais e TODO's

O código precisa de mais refinamento. Aqui está uma lista incompleta de problemas e TODO's

• Nenhuma maneira fácil de oferecer suporte a um local de marcação personalizado pelo usuário (para grade curvilínea). Uma nova classe Locator precisa ser criada.

• FloatingAxis pode ter limites de coordenadas, por exemplo, um eixo flutuante de x = 0, mas y abrange apenas de 0 a 1.

• A localização do axislabel de FloatingAxis precisa ser fornecida opcionalmente como um valor de coordenada. ex, um eixo flutuante de x=0 com rótulo em y=1