Hochauflösende Triskonturierung mit Matplotlib

Einführung

In diesem Tutorial wird gezeigt, wie man mit Matplotlib hochauflösende Trikonturplots erstellt. Trikonturierung ist eine Technik, die verwendet wird, um Daten auf einem unstrukturierten Dreiecksnetz darzustellen. Sie wird häufig verwendet, wenn Daten an unregelmäßig verteilten Punkten gesammelt werden oder wenn die Daten von Natur aus dreieckig sind. Im Tutorial wird gezeigt, wie man eine zufällige Punktmenge generiert, eine Delaunay-Triangulation auf diesen Punkten durchführt, einige der Dreiecke im Netz ausblendet, die Daten verfeinert und interpoliert und schließlich die verfeinerten Daten mit der tricontour-Funktion von Matplotlib darstellt.

Tipps für die VM

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 der 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.

Importieren der erforderlichen Bibliotheken

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. In diesem Tutorial werden NumPy und Matplotlib verwendet.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.tri import TriAnalyzer, Triangulation, UniformTriRefiner

Definieren der Testfunktion

Als nächstes definieren wir eine Funktion, die die Ergebnisse eines Experiments repräsentiert. Diese Funktion wird verwendet, um die Testdatenpunkte zu generieren.

def experiment_res(x, y):
    """Eine analytische Funktion, die die Experimentergebnisse repräsentiert."""
    x = 2 * x
    r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2)
    theta1 = np.arctan2(0.5 - x, 0.5 - y)
    r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
    theta2 = np.arctan2(-x - 0.2, -y - 0.2)
    z = (4 * (np.exp((r1/10)**2) - 1) * 30 * np.cos(3 * theta1) +
         (np.exp((r2/10)**2) - 1) * 30 * np.cos(5 * theta2) +
         2 * (x**2 + y**2))
    return (np.max(z) - z) / (np.max(z) - np.min(z))

Generieren von Testdatenpunkten

Wir generieren eine Menge zufälliger Testdatenpunkte mit x- und y-Werten zwischen -1 und 1. Wir generieren auch eine entsprechende Menge von z-Werten, indem wir die in Schritt 2 definierte experiment_res-Funktion verwenden.

## User parameters for data test points

## Number of test data points, tested from 3 to 5000 for subdiv=3
n_test = 200

## Random points
random_gen = np.random.RandomState(seed=19680801)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)

Delaunay-Triangulation durchführen

Wir führen eine Delaunay-Triangulation auf den Testdatenpunkten durch, indem wir die Triangulation-Funktion aus dem matplotlib.tri-Modul verwenden.

## meshing with Delaunay triangulation
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]

Einige Dreiecke maskieren

Wir maskieren einige der Dreiecke im Gitter, um ungültige Daten zu simulieren. Wir wählen zufällig einen Teilmengen von Dreiecken basierend auf dem Parameter init_mask_frac aus.

## Some invalid data are masked out
mask_init = np.zeros(ntri, dtype=bool)
masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)

Triangulation verbessern

Wir verwenden einen TriAnalyzer, um die Triangulation zu verbessern, indem wir schlecht geformte (flache) Dreiecke von der Grenze der Triangulation entfernen. Anschließend wenden wir die Maske auf die Triangulation an, indem wir set_mask verwenden.

## masking badly shaped triangles at the border of the triangular mesh.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)

Daten verfeinern und interpolieren

Wir verfeinern und interpolieren die Daten, indem wir einen UniformTriRefiner verwenden.

## refining the data
refiner = UniformTriRefiner(tri)
tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

Die Daten plotten

Wir plotten die verfeinerten Daten mit der tricontour-Funktion von Matplotlib.

## Graphical options for tricontouring
levels = np.arange(0., 1., 0.025)

fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.set_title("Filtering a Delaunay mesh\n"
             "(application to high-resolution tricontouring)")

## plot of the refined (computed) data contours:
ax.tricontour(tri_refi, z_test_refi, levels=levels, cmap='Blues',
              linewidths=[2.0, 0.5, 1.0, 0.5])

plt.show()

Zusammenfassung

In diesem Tutorial wurde gezeigt, wie man mit Matplotlib hochauflösende Triskonturplots erstellt. Wir begannen damit, eine Menge zufälliger Testdatenpunkte zu generieren, eine Delaunay-Triangulation auf diesen Punkten durchzuführen, einige der Dreiecke im Gitter auszublenden, die Daten zu verfeinern und zu interpolieren und schließlich die verfeinerten Daten mit der tricontour-Funktion von Matplotlib zu plotten.

Tricontour Glatte Delaunay