Flache Objekte in 3D-Diagrammen zeichnen

Einführung

Matplotlib ist eine beliebte Datenvisualisierungsbibliothek in Python. Es bietet eine Vielzahl von Funktionen, um verschiedene Arten von Diagrammen und Grafiken zu erstellen. Eine der Eigenschaften von Matplotlib ist die Fähigkeit, flache Objekte in 3D-Diagrammen zu zeichnen. In diesem Lab werden Sie durch den Prozess der Zeichnung von flachen Objekten in 3D-Diagrammen mit Matplotlib geführt.

VM-Tipps

Nachdem der VM-Start 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 während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken, nämlich Matplotlib, NumPy und mpl_toolkits.mplot3d.art3d.

import matplotlib.pyplot as plt
import numpy as np
import mpl_toolkits.mplot3d.art3d as art3d

Erstellen eines 3D-Diagramms

Wir werden ein 3D-Diagramm mit der add_subplot-Funktion von Matplotlib erstellen. Der projection-Parameter wird auf '3d' gesetzt, um ein 3D-Diagramm zu erstellen.

fig = plt.figure()
ax = fig.add_subplot(projection='3d')

Zeichnen eines Kreises auf der Wand

Wir werden einen Kreis auf der x=0-'Wand' des 3D-Diagramms mit den Circle- und pathpatch_2d_to_3d-Funktionen von Matplotlib zeichnen.

p = Circle((5, 5), 3)
ax.add_patch(p)
art3d.pathpatch_2d_to_3d(p, z=0, zdir="x")

Bezeichnen der Achsen

Wir werden die Achsen manuell mit der text3d-Funktion bezeichnen. Die Funktion nimmt die Position des Texts, den anzuzeigenden Text, die Achse, die als dritte Dimension behandelt werden soll, und andere Parameter entgegen.

def text3d(ax, xyz, s, zdir="z", size=None, angle=0, usetex=False, **kwargs):
    """
    Plots the string *s* on the axes *ax*, with position *xyz*, size *size*,
    and rotation angle *angle*. *zdir* gives the axis which is to be treated as
    the third dimension. *usetex* is a boolean indicating whether the string
    should be run through a LaTeX subprocess or not.  Any additional keyword
    arguments are forwarded to `.transform_path`.

    Note: zdir affects the interpretation of xyz.
    """
    x, y, z = xyz
    if zdir == "y":
        xy1, z1 = (x, z), y
    elif zdir == "x":
        xy1, z1 = (y, z), x
    else:
        xy1, z1 = (x, y), z

    text_path = TextPath((0, 0), s, size=size, usetex=usetex)
    trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])

    p1 = PathPatch(trans.transform_path(text_path), **kwargs)
    ax.add_patch(p1)
    art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)


text3d(ax, (4, -2, 0), "X-axis", zdir="z", size=.5, usetex=False,
       ec="none", fc="k")
text3d(ax, (12, 4, 0), "Y-axis", zdir="z", size=.5, usetex=False,
       angle=np.pi / 2, ec="none", fc="k")
text3d(ax, (12, 10, 4), "Z-axis", zdir="y", size=.5, usetex=False,
       angle=np.pi / 2, ec="none", fc="k")

Schreiben einer Latex-Formel auf dem Boden

Wir werden eine Latex-Formel auf dem z=0-'Boden' des 3D-Diagramms mit der text3d-Funktion schreiben.

text3d(ax, (1, 5, 0),
       r"$\displaystyle G_{\mu\nu} + \Lambda g_{\mu\nu} = "
       r"\frac{8\pi G}{c^4} T_{\mu\nu}  $",
       zdir="z", size=1, usetex=True,
       ec="none", fc="k")

Setzen von Grenzen und Anzeigen des Diagramms

Wir werden die Grenzen der x-, y- und z-Achsen mit den set_xlim-, set_ylim- und set_zlim-Funktionen von Matplotlib setzen. Schließlich werden wir das 3D-Diagramm mit der show-Funktion von Matplotlib anzeigen.

ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_zlim(0, 10)

plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man flache Objekte in 3D-Diagrammen mit Matplotlib zeichnen kann. Wir haben ein 3D-Diagramm erstellt, einen Kreis auf der Wand gezeichnet, die Achsen bezeichnet, eine Latex-Formel auf dem Boden geschrieben und die Grenzen der Achsen gesetzt.