Showcase benutzerdefinierter Matplotlib-Projektion

Einführung

In diesem Lab werden wir lernen, wie man eine benutzerdefinierte Projektion mit Matplotlib erstellt. Wir werden die Hammer-Projektion vorführen, indem wir viele Funktionen von Matplotlib nutzen. Wir werden Python als Programmiersprache verwenden.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

Zunächst werden wir die erforderlichen Bibliotheken importieren, um eine benutzerdefinierte Projektion zu erstellen.

import numpy as np
import matplotlib
from matplotlib.axes import Axes
import matplotlib.axis as maxis
from matplotlib.patches import Circle
from matplotlib.path import Path
from matplotlib.projections import register_projection
import matplotlib.spines as mspines
from matplotlib.ticker import FixedLocator, Formatter, NullLocator
from matplotlib.transforms import Affine2D, BboxTransformTo, Transform

Erstellen der Klasse GeoAxes

Wir werden eine abstrakte Basisklasse für geografische Projektionen namens GeoAxes erstellen.

class GeoAxes(Axes):
    """
    An abstract base class for geographic projections
    """

    class ThetaFormatter(Formatter):
        """
        Used to format the theta tick labels.  Converts the native
        unit of radians into degrees and adds a degree symbol.
        """
        def __init__(self, round_to=1.0):
            self._round_to = round_to

        def __call__(self, x, pos=None):
            degrees = round(np.rad2deg(x) / self._round_to) * self._round_to
            return f"{degrees:0.0f}\N{DEGREE SIGN}"

    RESOLUTION = 75

    def _init_axis(self):
        self.xaxis = maxis.XAxis(self)
        self.yaxis = maxis.YAxis(self)
        ## Do not register xaxis or yaxis with spines -- as done in
        ## Axes._init_axis() -- until GeoAxes.xaxis.clear() works.
        ## self.spines['geo'].register_axis(self.yaxis)

    def clear(self):
        ## docstring inherited
        super().clear()

        self.set_longitude_grid(30)
        self.set_latitude_grid(15)
        self.set_longitude_grid_ends(75)
        self.xaxis.set_minor_locator(NullLocator())
        self.yaxis.set_minor_locator(NullLocator())
        self.xaxis.set_ticks_position('none')
        self.yaxis.set_ticks_position('none')
        self.yaxis.set_tick_params(label1On=True)
        ## Why do we need to turn on yaxis tick labels, but
        ## xaxis tick labels are already on?

        self.grid(rcParams['axes.grid'])

        Axes.set_xlim(self, -np.pi, np.pi)
        Axes.set_ylim(self, -np.pi / 2.0, np.pi / 2.0)

Erstellen der Klasse HammerAxes

Wir werden eine benutzerdefinierte Klasse für die Aitoff-Hammer-Projektion, eine flächengleiche Kartendarstellung, namens HammerAxes erstellen.

class HammerAxes(GeoAxes):
    """
    A custom class for the Aitoff-Hammer projection, an equal-area map
    projection.

    https://en.wikipedia.org/wiki/Hammer_projection
    """

    ## Die Projektion muss einen Namen angeben. Dies wird vom Benutzer
    ## verwendet, um die Projektion auszuwählen,
    ## z. B. ``subplot(projection='custom_hammer')``.
    name = 'custom_hammer'

    class HammerTransform(Transform):
        """Die grundlegende Hammer-Transformation."""
        input_dims = output_dims = 2

        def __init__(self, resolution):
            """
            Erstellt eine neue Hammer-Transformation. Die Auflösung ist die Anzahl
            der Schritte, um zwischen jedem Eingabelinearschnitt zu interpolieren,
            um seinen Pfad im gekrümmten Hammer-Raum zu approximieren.
            """
            Transform.__init__(self)
            self._resolution = resolution

        def transform_non_affine(self, ll):
            longitude, latitude = ll.T

            ## Vor-Berechnung einiger Werte
            half_long = longitude / 2
            cos_latitude = np.cos(latitude)
            sqrt2 = np.sqrt(2)

            alpha = np.sqrt(1 + cos_latitude * np.cos(half_long))
            x = (2 * sqrt2) * (cos_latitude * np.sin(half_long)) / alpha
            y = (sqrt2 * np.sin(latitude)) / alpha
            return np.column_stack([x, y])

        def transform_path_non_affine(self, path):
            ## vertices = path.vertices
            ipath = path.interpolated(self._resolution)
            return Path(self.transform(ipath.vertices), ipath.codes)

        def inverted(self):
            return HammerAxes.InvertedHammerTransform(self._resolution)

    class InvertedHammerTransform(Transform):
        input_dims = output_dims = 2

        def __init__(self, resolution):
            Transform.__init__(self)
            self._resolution = resolution

        def transform_non_affine(self, xy):
            x, y = xy.T
            z = np.sqrt(1 - (x / 4) ** 2 - (y / 2) ** 2)
            longitude = 2 * np.arctan((z * x) / (2 * (2 * z ** 2 - 1)))
            latitude = np.arcsin(y*z)
            return np.column_stack([longitude, latitude])

        def inverted(self):
            return HammerAxes.HammerTransform(self._resolution)

    def __init__(self, *args, **kwargs):
        self._longitude_cap = np.pi / 2.0
        super().__init__(*args, **kwargs)
        self.set_aspect(0.5, adjustable='box', anchor='C')
        self.clear()

    def _get_core_transform(self, resolution):
        return self.HammerTransform(resolution)

Projektion registrieren

Jetzt werden wir die Projektion bei Matplotlib registrieren, sodass der Benutzer sie auswählen kann.

register_projection(HammerAxes)

Beispiel erstellen

Schließlich werden wir ein Beispiel mit der benutzerdefinierten Projektion erstellen.

if __name__ == '__main__':
    import matplotlib.pyplot as plt

    ## Jetzt erstellen wir ein einfaches Beispiel mit der benutzerdefinierten Projektion.
    fig, ax = plt.subplots(subplot_kw={'projection': 'custom_hammer'})
    ax.plot([-1, 1, 1], [-1, -1, 1], "o-")
    ax.grid()

    plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man eine benutzerdefinierte Projektion mit Matplotlib erstellt. Wir haben eine benutzerdefinierte Projektion namens Hammer-Projektion erstellt, indem wir viele Funktionen von Matplotlib vereinfacht haben. Wir haben gelernt, wie man die Klasse GeoAxes, die Klasse HammerAxes erstellt, die Projektion registriert und ein Beispiel mit der benutzerdefinierten Projektion erstellt.