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.