Überblick über das axisartist-Toolkit

Das axisartist-Toolkit-Tutorial.

Warnung

axisartist verwendet eine benutzerdefinierte Axes-Klasse (abgeleitet von der ursprünglichen Axes-Klasse der Matplotlib). Als Nebeneffekt funktionieren einige Befehle (meistens Tick-bezogen) nicht.

Der axisartist enthält eine benutzerdefinierte Axes-Klasse, die krummlinige Gitter unterstützen soll (z. B. das Weltkoordinatensystem in der Astronomie). Anders als die ursprüngliche Axes-Klasse von Matplotlib, die Axes.xaxis und Axes.yaxis verwendet, um Ticks, Ticklines usw. zu zeichnen, verwendet axisartist einen speziellen Künstler (AxisArtist), der Ticks, Ticklines usw. für gekrümmte Koordinatensysteme verarbeiten kann.

Da es spezielle Künstler verwendet, funktionieren einige Matplotlib-Befehle, die auf Axes.xaxis und Axes.yaxis funktionieren, möglicherweise nicht.

Achsenkünstler

Das axisartist -Modul bietet eine benutzerdefinierte (und sehr experimentelle) Axes-Klasse, bei der jede Achse (links, rechts, oben und unten) einen separaten zugeordneten Künstler hat, der für das Zeichnen der Achsenlinie, Ticks, Ticklabels und Beschriftungen verantwortlich ist. Sie können auch Ihre eigene Achse erstellen, die durch eine feste Position in den Achsenkoordinaten oder eine feste Position in den Datenkoordinaten gehen kann (dh die Achse schwebt herum, wenn sich die Sichtbegrenzung ändert).

Die X- und Y-Achse der Axes-Klasse sind standardmäßig unsichtbar und es gibt 4 zusätzliche Künstler, die für das Zeichnen der 4-Achsen-Stacheln in "links", "rechts", "unten" und "oben" verantwortlich sind. Auf sie wird als ax.axis["left"], ax.axis["right"] usw. zugegriffen, dh ax.axis ist ein Wörterbuch, das Künstler enthält (beachten Sie, dass ax.axis immer noch eine aufrufbare Methode ist und es verhält sich wie eine ursprüngliche Axes.axis-Methode in Matplotlib).

Um eine Achse zu erstellen,

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

oder um eine Nebenhandlung zu erstellen

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)

Sie können beispielsweise die rechten und oberen Stacheln ausblenden mit:

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

Es ist auch möglich, eine horizontale Achse hinzuzufügen. Beispielsweise können Sie eine horizontale Achse bei y=0 (in Datenkoordinaten) haben.

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

Oder eine feste Achse mit etwas Versatz

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

axisartist mit ParasiteAxes

Die meisten Befehle im Axes_grid1-Toolkit können ein Axes_class-Schlüsselwortargument annehmen, und die Befehle erstellen Axes der angegebenen Klasse. Um beispielsweise einen Host-Subplot mit axisartist.Axes zu erstellen,

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

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

Hier ist ein Beispiel, das ParasiteAxes verwendet.

Krummliniges Gitter

Die Motivation hinter dem AxisArtist-Modul ist die Unterstützung eines krummlinigen Gitters und Ticks.

Schwebende Äxte

AxisArtist unterstützt auch Floating Axes, deren äußere Achsen als Floating Axis definiert sind.

axisartist-Namensraum

Der Namespace axisartist enthält eine abgeleitete Axes-Implementierung. Der größte Unterschied besteht darin, dass die Künstler, die für das Zeichnen von Achsenlinien, Ticks, Ticklabel und Achsenbeschriftungen verantwortlich sind, von der Axis-Klasse der Matplotlib getrennt sind, die viel mehr als Künstler in der ursprünglichen Matplotlib sind. Diese Änderung war stark motiviert, um ein krummliniges Gitter zu unterstützen. Hier sind ein paar Dinge, die mpl_toolkits.axisartist.Axes von den ursprünglichen Axes von Matplotlib unterscheidet.

• Achsenelemente (Achsenlinie (Rückgrat), Ticks, Ticklabel und Achsenbeschriftungen) werden von einer AxisArtist-Instanz gezeichnet. Im Gegensatz zu Axis werden linke, rechte, obere und untere Achse von separaten Künstlern gezeichnet. Und jeder von ihnen kann unterschiedliche Tick-Positionen und unterschiedliche Tick-Labels haben.

• Gitternetzlinien werden von einer Gridlines-Instanz gezeichnet. Die Änderung wurde dadurch begründet, dass in krummlinigen Koordinaten eine Gitterlinie keine Achsenlinien kreuzen darf (dh keine zugeordneten Häkchen). In der ursprünglichen Axes-Klasse sind Gitterlinien an Ticks gebunden.

• Ticklines können bei Bedarf gedreht werden (d. h. entlang der Gitterlinien)

Zusammenfassend war all diese Änderungen zu unterstützen

• ein krummliniges Gitter.

• eine schwebende Achse

Die Klasse mpl_toolkits.axisartist.Axes definiert ein Achsenattribut , das ein Wörterbuch von AxisArtist-Instanzen ist. Standardmäßig hat das Wörterbuch 4 AxisArtist-Instanzen, die für das Zeichnen der linken, rechten, unteren und oberen Achse verantwortlich sind.

xaxis- und yaxis-Attribute sind weiterhin verfügbar, jedoch auf nicht sichtbar gesetzt. Da separate Künstler zum Rendern von Achsen verwendet werden, haben einige achsenbezogene Methoden in Matplotlib möglicherweise keine Auswirkung. Zusätzlich zu den AxisArtist-Instanzen haben die mpl_toolkits.axisartist.Axes das Attribut gridlines (Gridlines), das offensichtlich Gitterlinien zeichnet.

Sowohl in AxisArtist als auch in Gridlines wird die Berechnung der Tick- und Grid-Position an eine Instanz der GridHelper-Klasse delegiert. Die Klasse mpl_toolkits.axisartist.Axes verwendet GridHelperRectlinear als Rasterhelfer. Die GridHelperRectlinear-Klasse ist ein Wrapper um die x- und y -Achse der ursprünglichen Achsen von Matplotlib und sollte so funktionieren, wie die ursprünglichen Achsen von Matplotlib funktionieren. Beispielsweise sollten Tick-Positionsänderungen mit der set_ticks-Methode usw. wie erwartet funktionieren. Aber eine Änderung der Künstlereigenschaften (z. B. Farbe) wird im Allgemeinen nicht funktionieren, obwohl einige Anstrengungen unternommen wurden, damit einige sich häufig ändernde Attribute (Farbe usw.) berücksichtigt werden.

AxisArtist

AxisArtist kann als Container-Künstler mit folgenden Attributen betrachtet werden, die Häkchen, Beschriftungen usw. zeichnen.

• Linie

• major_ticks, major_ticklabels

• Minor_Ticks, Minor_Ticklabels

• offsetText

• Etikett

Zeile

Abgeleitet von der Line2D-Klasse. Verantwortlich für das Zeichnen einer Wirbelsäulenlinie (?).

major_ticks, minor_ticks

Abgeleitet von der Line2D-Klasse. Beachten Sie, dass Ticks Markierungen sind.

major_ticklabels, minor_ticklabels

Abgeleitet von Text. Beachten Sie, dass es sich nicht um eine Liste von Textkünstlern handelt, sondern um einen einzelnen Künstler (ähnlich einer Sammlung).

Achsenlabel

Abgeleitet von Text.

Standard AxisArtists

Standardmäßig sind folgende Achsenkünstler definiert:

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

Die Ticklabels und das Axislabel der oberen und der rechten Achse sind auf nicht sichtbar gesetzt.

Zum Beispiel, wenn Sie die Farbattribute von major_ticklabels der unteren x-Achse ändern möchten

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

Ähnlich, um Ticklabels unsichtbar zu machen

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

AxisArtist stellt eine Hilfsmethode bereit, um die Sichtbarkeit von Ticks, Ticklabels und Labels zu steuern. Um ticklabel unsichtbar zu machen,

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

Um alle Ticks, Ticklabels und (Achsen-)Labels unsichtbar zu machen

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

Um alle auszuschalten, aber Häkchen an

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

Um alles einzuschalten, außer (Achsen-)Beschriftung aus

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

Die Methode __getitem__ von ax.axis kann mehrere Achsennamen annehmen. Um beispielsweise die Ticklabels der "oberen" und "rechten" Achse einzuschalten,

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

Beachten Sie, dass ein einfaches Proxy-Objekt zurückgegeben wird, das den obigen Code in etwas wie unten übersetzt.ax.axis["top", "right"]

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

Daher werden alle Rückgabewerte in der for-Schleife ignoriert. Und Sie sollten es nicht mehr als eine einfache Methode verwenden.

Wie die Listenindizierung bedeutet ":" alle Elemente, dh

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

ändert die Strichfarbe in allen Achsen.

Anleitung

1. Tick-Positionen und Beschriftung ändern.

Gleich wie die Achsen der ursprünglichen Matplotlib:

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

2. Ändern von Achseneigenschaften wie Farbe usw.

Ändern Sie die Eigenschaften der entsprechenden Künstler. Um beispielsweise die Farbe der Ticklabels zu ändern:

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

3. So ändern Sie die Attribute mehrerer Achsen:

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

   oder um die Attribute aller Achsen zu ändern:

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

4. Um die Tick-Größe (Länge) zu ändern, müssen Sie die Methode axis.major_ticks.set_ticksize verwenden. Verwenden Sie die Methode axis.major_ticks.set_tick_out, um die Richtung der Ticks zu ändern (Ticks sind standardmäßig in entgegengesetzter Richtung von Ticklabels).

   Um das Pad zwischen Ticks und Ticklabels zu ändern, verwenden Sie die Methode axis.major_ticklabels.set_pad.

   Um das Pad zwischen Ticklabels und Achsenbeschriftung zu ändern, die Methode axis.label.set_pad.

Rotation und Ausrichtung von TickLabels

Dies unterscheidet sich auch stark von Standard-Matplotlib und kann verwirrend sein. Wenn Sie die Ticklabels drehen möchten, sollten Sie zuerst die Methode "set_axis_direction" verwenden.

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

Der Parameter für set_axis_direction ist einer von ["links", "rechts", "unten", "oben"].

Sie müssen ein zugrunde liegendes Konzept von Richtungen verstehen.

• Es gibt eine Bezugsrichtung, die als Richtung der Achsenlinie mit steigender Koordinate definiert ist. Beispielsweise ist die Bezugsrichtung der linken x-Achse von unten nach oben.

  Die Richtung, der Textwinkel und die Ausrichtung der Teilstriche, Teilstrichbeschriftungen und Achsenbeschriftungen werden in Bezug auf die Referenzrichtung bestimmt

• label_direction und ticklabel_direction sind entweder die rechte Seite (+) der Bezugsrichtung oder die linke Seite (-).

• Ticks werden standardmäßig in die entgegengesetzte Richtung der Ticklabels gezeichnet.

• Textrotation von Ticklabels und Label wird in Bezug auf die Ticklabel_Richtung bzw. Label_Richtung bestimmt . Die Rotation von Ticklabels und Label ist verankert.

Andererseits gibt es ein Konzept von "axis_direction". Dies ist eine Standardeinstellung der obigen Eigenschaften für jede „untere“, „linke“, „obere“ und „rechte“ Achse.

?	?	links	Unterseite	Rechts	oben
Achsenbeschriftung	Richtung	'-'	'+'	'+'	'-'
Achsenbeschriftung	Drehung	180	0	0	180
Achsenbeschriftung	va	Center	oben	Center	Unterseite
Achsenbeschriftung	Ha	Rechts	Center	Rechts	Center
Häkchen	Richtung	'-'	'+'	'+'	'-'
Ticklabels	Drehung	90	0	-90	180
Häkchen	Ha	Rechts	Center	Rechts	Center
Häkchen	va	Center	Grundlinie	Center	Grundlinie

Und 'set_axis_direction("top")' bedeutet, die Textdrehung usw. anzupassen, für Einstellungen, die für die "obere" Achse geeignet sind. Das Konzept der Achsenrichtung kann mit gekrümmten Achsen klarer werden.

Die axis_direction kann auf der AxisArtist-Ebene oder auf der Ebene ihrer untergeordneten Künstler, dh Ticks, Ticklabels und Axis-Label, angepasst werden.

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

Ändert die Achsenrichtung aller zugeordneten Künstler mit der "linken" Achse, während

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

ändert die axis_direction nur der major_ticklabels. Beachten Sie, dass set_axis_direction in der AxisArtist-Ebene ticklabel_direction und label_direction ändert, während eine Änderung der axis_direction von Ticks, ticklabels und axis-label sie nicht beeinflusst.

Wenn Sie Ticks nach außen und Ticklabels innerhalb der Achsen machen möchten, verwenden Sie die Methode invert_ticklabel_direction.

ax.axis[:].invert_ticklabel_direction()

Eine verwandte Methode ist "set_tick_out". Es macht Ticks nach außen (tatsächlich macht es Ticks in die entgegengesetzte Richtung der Standardrichtung).

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

Zusammenfassend also

• Die Methoden von AxisArtist

  • set_axis_direction: „links“, „rechts“, „unten“ oder „oben“

  • set_ticklabel_direction: "+" oder "-"

  • set_axislabel_direction: "+" oder "-"

  • invert_ticklabel_direction

• Ticks-Methoden (major_ticks und minor_ticks)

  • set_tick_out: Wahr oder falsch

  • set_ticksize: Größe in Punkten

• Methoden von TickLabels (major_ticklabels und minor_ticklabels)

  • set_axis_direction: „links“, „rechts“, „unten“ oder „oben“

  • set_rotation: Winkel in Bezug auf die Bezugsrichtung

  • set_ha und set_va: siehe unten

• Methoden von AxisLabels (Label)

  • set_axis_direction: „links“, „rechts“, „unten“ oder „oben“

  • set_rotation: Winkel in Bezug auf die Bezugsrichtung

  • set_ha und set_va

Ausrichtung der Ticklabels anpassen

Ausrichtung von TickLabels werden speziell behandelt. Siehe unten

Einstellkissen

Zum Wechseln des Pads zwischen Ticks und Ticklabels

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

Oder ticklabels und axis-label

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

GridHelper

Um tatsächlich eine krummlinige Koordinate zu definieren, müssen Sie Ihren eigenen Gitterhelfer verwenden. Eine verallgemeinerte Version der Grid-Hilfsklasse wird bereitgestellt und diese Klasse sollte in den meisten Fällen ausreichen. Ein Benutzer kann zwei Funktionen bereitstellen, die eine Transformation (und ihr inverses Paar) von der gekrümmten Koordinate zur (geradlinigen) Bildkoordinate definieren. Beachten Sie, dass, während Teilstriche und Gitter für gekrümmte Koordinaten gezeichnet werden, die Datentransformation der Achsen selbst (ax.transData) immer noch geradlinige (Bild-)Koordinaten sind.

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)

Sie können stattdessen die Transform-Instanz von Matplotlib verwenden (aber eine inverse Transformation muss definiert werden). Häufig kann der Koordinatenbereich in einem gekrümmten Koordinatensystem einen begrenzten Bereich haben oder Zyklen aufweisen. In diesen Fällen ist eine angepasstere Version von Grid Helper erforderlich.

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
                                    )

Auch hier ist das transData der Achsen immer noch eine geradlinige Koordinate (Bildkoordinate). Sie können die Konvertierung zwischen zwei Koordinaten manuell durchführen oder der Einfachheit halber Parasite Axes verwenden.:

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

Eine schwebende Achse ist eine Achse, von der eine Datenkoordinate fest ist, dh ihre Position ist nicht in den Achsenkoordinaten festgelegt, sondern ändert sich, wenn sich die Achsendatengrenzen ändern. Eine Floating-Achse kann mit der Methode new_floating_axis erstellt werden. Es liegt jedoch in Ihrer Verantwortung, dass der resultierende AxisArtist ordnungsgemäß zu den Achsen hinzugefügt wird. Eine empfohlene Methode besteht darin, es als Element des Achsenattributs von Axes hinzuzufügen.:

# 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)

Siehe das erste Beispiel dieser Seite.

Aktuelle Einschränkungen und TODOs

Der Code muss weiter verfeinert werden. Hier ist eine unvollständige Liste von Problemen und TODOs

• Keine einfache Möglichkeit, eine vom Benutzer angepasste Tick-Position zu unterstützen (für krummliniges Gitter). Eine neue Locator-Klasse muss erstellt werden.

• FloatingAxis kann Koordinatengrenzen haben, z. B. eine Floating-Achse von x = 0, aber y erstreckt sich nur von 0 bis 1.

• Die Position des Achsenlabels von FloatingAxis muss optional als Koordinatenwert angegeben werden. z. B. eine schwebende Achse von x = 0 mit Beschriftung bei y = 1