matplotlib.tri

Funktionen für unstrukturierte Dreiecksnetze.

class matplotlib.tri.Triangulation(x, y, triangles=None, mask=None)

Ein unstrukturiertes Dreiecksnetz bestehend aus n-Punkten und n-Dreiecken. Die Dreiecke können entweder vom Benutzer spezifiziert oder automatisch mittels Delaunay-Triangulation generiert werden.

Parameter:

x, y(npoints,) array-ähnlich

Koordinaten der Gitterpunkte.

triangles(ntri, 3) array-ähnlich von int, optional

Für jedes Dreieck die Indizes der drei Punkte, aus denen das Dreieck besteht, in gegen den Uhrzeigersinn geordnet. Falls nicht angegeben, wird die Delaunay-Triangulation berechnet.

mask(ntri,) array-ähnlich von bool, optional

Welche Dreiecke maskiert sind.

Attribute:

triangles(ntri, 3) array von int

Für jedes Dreieck die Indizes der drei Punkte, aus denen das Dreieck besteht, in gegen den Uhrzeigersinn geordnet. Wenn Sie die *mask* berücksichtigen möchten, verwenden Sie stattdessen get_masked_triangles.

mask(ntri, 3) array von bool oder None

Maskierte Dreiecke.

is_delaunaybool

Ob die Triangulation eine berechnete Delaunay-Triangulation ist (wenn *triangles* nicht angegeben wurde) oder nicht.

Anmerkungen

Damit eine Triangulation gültig ist, darf sie keine doppelten Punkte, aus kollinearen Punkten gebildete Dreiecke oder überlappende Dreiecke enthalten.

calculate_plane_coefficients(z)

Berechnet die Koeffizienten der Ebenengleichung für alle nicht maskierten Dreiecke aus den (x, y)-Koordinaten und dem angegebenen z-Array der Form (npoints). Das zurückgegebene Array hat die Form (npoints, 3) und ermöglicht die Berechnung des z-Werts an der Position (x, y) in Dreieck tri mittels z = array[tri, 0] * x  + array[tri, 1] * y + array[tri, 2].

property edges

Gibt ein Integer-Array der Form (nedges, 2) zurück, das alle Kanten von nicht maskierten Dreiecken enthält.

Jede Zeile definiert eine Kante durch ihren Start- und Endpunktindex. Jede Kante erscheint nur einmal, d.h. für eine Kante zwischen den Punkten *i* und *j* gibt es nur entweder * (i, j)* oder * (j, i)*.

get_cpp_triangulation()

Gibt das zugrunde liegende C++-Triangulationsobjekt zurück und erstellt es bei Bedarf.

static get_from_args_and_kwargs(*args, **kwargs)

Gibt ein Triangulationsobjekt aus den Args und Kwargs sowie die restlichen Args und Kwargs mit den verbrauchten Werten entfernt zurück.

Es gibt zwei Alternativen: Entweder ist das erste Argument ein Triangulationsobjekt, in diesem Fall wird es zurückgegeben, oder die Args und Kwargs reichen aus, um eine neue Triangulation zu erstellen und zurückzugeben. Im letzteren Fall siehe Triangulation. __init__ für die möglichen Args und Kwargs.

get_masked_triangles()

Gibt ein Array von Dreiecken zurück, das die Maske berücksichtigt.

get_trifinder()

Gibt den Standard-matplotlib.tri.TriFinder dieser Triangulation zurück und erstellt ihn bei Bedarf. Dies ermöglicht eine einfache gemeinsame Nutzung desselben TriFinder-Objekts.

property neighbors

Gibt ein Integer-Array der Form (ntri, 3) mit Nachbardreiecken zurück.

Für jedes Dreieck die Indizes der drei Dreiecke, die sich die gleichen Kanten teilen, oder -1, wenn kein solches Nachbardreieck vorhanden ist. neighbors[i, j] ist das Dreieck, das der Kante vom Punktindex triangles[i, j] zum Punktindex triangles[i, (j+1)%3] benachbart ist.

set_mask(mask)

Setzt oder löscht das Maskierungsarray.

Parameter:

maskNone oder bool-Array der Länge ntri

class matplotlib.tri.TriContourSet(ax, *args, **kwargs)

Bases: ContourSet

Erstellt und speichert einen Satz von Konturlinien oder gefüllten Regionen für ein Dreiecksnetz.

Diese Klasse wird normalerweise nicht direkt vom Benutzer instanziiert, sondern von tricontour und tricontourf.

Attribute:

levelsarray

Die Werte der Konturlinien.

layersarray

Gleich wie levels für Linienkonturen; auf halbem Weg zwischen den Levels für gefüllte Konturen. Siehe ContourSet._process_colors.

Zeichnet Konturlinien oder gefüllte Regionen eines Dreiecksnetzes, abhängig davon, ob das Schlüsselwort-Argument *filled* False (Standard) oder True ist.

Das erste Argument des Initialisierers muss ein Axes-Objekt sein. Die übrigen Argumente und Schlüsselwort-Argumente werden in der Docstring von tricontour beschrieben.

set(*, agg_filter=<UNSET>, alpha=<UNSET>, animated=<UNSET>, antialiased=<UNSET>, array=<UNSET>, capstyle=<UNSET>, clim=<UNSET>, clip_box=<UNSET>, clip_on=<UNSET>, clip_path=<UNSET>, cmap=<UNSET>, color=<UNSET>, edgecolor=<UNSET>, facecolor=<UNSET>, gid=<UNSET>, hatch=<UNSET>, hatch_linewidth=<UNSET>, in_layout=<UNSET>, joinstyle=<UNSET>, label=<UNSET>, linestyle=<UNSET>, linewidth=<UNSET>, mouseover=<UNSET>, norm=<UNSET>, offset_transform=<UNSET>, offsets=<UNSET>, path_effects=<UNSET>, paths=<UNSET>, picker=<UNSET>, pickradius=<UNSET>, rasterized=<UNSET>, sketch_params=<UNSET>, snap=<UNSET>, transform=<UNSET>, url=<UNSET>, urls=<UNSET>, visible=<UNSET>, zorder=<UNSET>)

Setzt mehrere Eigenschaften auf einmal.

Unterstützte Eigenschaften sind

Eigenschaft	Beschreibung
agg_filter	eine Filterfunktion, die ein (m, n, 3) Float-Array und einen dpi-Wert entgegennimmt und ein (m, n, 3) Array und zwei Offsets von der linken unteren Ecke des Bildes zurückgibt
alpha	Array-ähnlich oder float oder None
animated	bool
antialiased oder aa oder antialiaseds	bool oder Liste von bools
Array	Array-ähnlich oder None
capstyle	CapStyle oder {'butt', 'projecting', 'round'}
clim	(vmin: float, vmax: float)
clip_box	BboxBase oder None
clip_on	bool
clip_path	Patch oder (Path, Transform) oder None
cmap	Colormap oder str oder None
color	Farbe oder Liste von RGBA-Tupeln
edgecolor oder ec oder edgecolors	Farbe oder Liste von Farben oder 'face'
facecolor oder facecolors oder fc	Farbe oder Liste von Farben
figure	Figure oder SubFigure
gid	str
Muster (hatch)	{'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
hatch_linewidth	unknown
in_layout	bool
joinstyle	JoinStyle oder {'miter', 'round', 'bevel'}
label	object
linestyle oder dashes oder linestyles oder ls	str oder Tupel oder Liste davon
linewidth oder linewidths oder lw	float oder Liste von floats
mouseover	bool
norm	Normalize oder str oder None
offset_transform oder transOffset	Transform
offsets	(N, 2) oder (2,) Array-ähnlich
path_effects	liste von AbstractPathEffect
paths	unknown
picker	None oder bool oder float oder callable
pickradius	float
rasterized	bool
sketch_params	(scale: float, length: float, randomness: float)
snap	bool oder None
transform	Transform
url	str
urls	Liste von str oder None
visible	bool
zorder	float

class matplotlib.tri.TriFinder(triangulation)

Abstrakte Basisklasse für Klassen, die zum Finden der Dreiecke einer Triangulation verwendet werden, in denen (x, y)-Punkte liegen.

Anstatt ein Objekt einer von TriFinder abgeleiteten Klasse zu instanziieren, ist es normalerweise besser, die Funktion Triangulation.get_trifinder zu verwenden.

Abgeleitete Klassen implementieren __call__(x, y), wobei x und y array-ähnliche Punktkoordinaten derselben Form sind.

class matplotlib.tri.TrapezoidMapTriFinder(triangulation)

Bases: TriFinder

TriFinder-Klasse, implementiert mithilfe des Trapezoidkartenalgorithmus aus dem Buch "Computational Geometry, Algorithms and Applications", zweite Auflage, von M. de Berg, M. van Kreveld, M. Overmars und O. Schwarzkopf.

Die Triangulation muss gültig sein, d.h. sie darf keine doppelten Punkte, aus kollinearen Punkten gebildete Dreiecke oder überlappende Dreiecke enthalten. Der Algorithmus ist bis zu einem gewissen Grad tolerant gegenüber Dreiecken, die aus kollinearen Punkten gebildet werden, aber darauf sollte man sich nicht verlassen.

class matplotlib.tri.TriInterpolator(triangulation, z, trifinder=None)

Abstrakte Basisklasse für Klassen, die zur Interpolation auf einem Dreiecksnetz verwendet werden.

Abgeleitete Klassen implementieren die folgenden Methoden

• __call__(x, y), wobei x, y array-ähnliche Punktkoordinaten derselben Form sind und ein Maskenarray derselben Form mit den interpolierten z-Werten zurückgegeben wird.

• gradient(x, y), wobei x, y array-ähnliche Punktkoordinaten derselben Form sind und eine Liste von 2 Maskenarrays derselben Form zurückgegeben wird, die die 2 Ableitungen des Interpolators enthalten (Ableitungen der interpolierten z-Werte in Bezug auf x und y).

class matplotlib.tri.LinearTriInterpolator(triangulation, z, trifinder=None)

Bases: TriInterpolator

Linearer Interpolator auf einem Dreiecksnetz.

Jedes Dreieck wird durch eine Ebene repräsentiert, sodass ein interpolierter Wert am Punkt (x, y) auf der Ebene des Dreiecks liegt, das (x, y) enthält. Interpolierte Werte sind daher kontinuierlich über die Triangulation hinweg, aber ihre ersten Ableitungen sind an den Kanten zwischen Dreiecken diskontinuierlich.

Parameter:

triangulationTriangulation

Die Triangulation, über die interpoliert werden soll.

z(npoints,) array-ähnlich

Array von Werten, die an den Gitterpunkten definiert sind und zwischen denen interpoliert werden soll.

trifinderTriFinder, optional

Wenn dies nicht angegeben ist, wird der Standard-TriFinder der Triangulation durch Aufruf von Triangulation.get_trifinder verwendet.

Methoden

`__call__` (x, y)	(Gibt interpolierte Werte an den (x, y)-Punkten zurück.)
`gradient` (x, y)	(Gibt interpolierte Ableitungen an den (x, y)-Punkten zurück.)

gradient(x, y)

Gibt eine Liste von 2 Maskenarrays zurück, die interpolierte Ableitungen an den angegebenen (x, y)-Punkten enthalten.

Parameter:

x, yarray-ähnlich

x- und y-Koordinaten gleicher Form und beliebiger Dimensionalität.

Gibt zurück:

dzdx, dzdynp.ma.array

2 Maskenarrays mit der gleichen Form wie *x* und *y*; Werte, die zu (x, y)-Punkten außerhalb der Triangulation gehören, sind maskiert. Das erste zurückgegebene Array enthält die Werte von \(\frac{\partial z}{\partial x}\) und das zweite die Werte von \(\frac{\partial z}{\partial y}\).

class matplotlib.tri.CubicTriInterpolator(triangulation, z, kind='min_E', trifinder=None, dz=None)

Bases: TriInterpolator

Kubischer Interpolator auf einem Dreiecksnetz.

Eindimensional - auf einem Segment - wird eine kubische Interpolationsfunktion durch die Werte der Funktion und ihrer Ableitung an beiden Enden definiert. Dies ist in 2D innerhalb eines Dreiecks fast dasselbe, außer dass die Werte der Funktion und ihrer 2 Ableitungen an jedem Dreiecksknoten definiert sein müssen.

Der CubicTriInterpolator nimmt den vom Benutzer bereitgestellten Wert der Funktion an jedem Knoten und berechnet intern den Wert der Ableitungen, was zu einer glatten Interpolation führt. (Als besonderes Merkmal kann der Benutzer auch den Wert der Ableitungen an jedem Knoten vorgeben, dies ist jedoch nicht die übliche Verwendung.)

Parameter:

triangulationTriangulation

Die Triangulation, über die interpoliert werden soll.

z(npoints,) array-ähnlich

Array von Werten, die an den Gitterpunkten definiert sind und zwischen denen interpoliert werden soll.

kind{'min_E', 'geom', 'user'}, optional

Auswahl des Glättungsalgorithmus zur Berechnung der Ableitungen des Interpolanten (Standard: 'min_E')

• wenn 'min_E': (Standard) Die Ableitungen an jedem Knoten werden berechnet, um die Biegeenergie zu minimieren.

• wenn 'geom': Die Ableitungen an jedem Knoten werden als gewichteter Durchschnitt relevanter Dreiecksnormale berechnet. Zur Geschwindigkeitsoptimierung (große Gitter) zu verwenden.

• wenn 'user': Der Benutzer stellt das Argument *dz* bereit, es ist daher keine Berechnung erforderlich.

trifinderTriFinder, optional

Wenn nicht angegeben, wird der Standard-TriFinder der Triangulation durch Aufruf von Triangulation.get_trifinder verwendet.

dzTupel aus Array-ähnlichen Objekten (dzdx, dzdy), optional

Nur verwendet, wenn *kind* = 'user'. In diesem Fall muss *dz* als (dzdx, dzdy) angegeben werden, wobei dzdx, dzdy Arrays mit der gleichen Form wie *z* sind und die ersten Ableitungen des Interpolanten an den *triangulation*-Punkten darstellen.

Methoden

`__call__` (x, y)	(Gibt interpolierte Werte an den (x, y)-Punkten zurück.)
`gradient` (x, y)	(Gibt interpolierte Ableitungen an den (x, y)-Punkten zurück.)

Anmerkungen

Diese Anmerkung ist etwas technisch und beschreibt, wie die kubische Interpolation berechnet wird.

Die Interpolation basiert auf einem Clough-Tocher-Unterteilungschema des *triangulation*-Netzes (um es klarer zu machen, jedes Dreieck des Netzes wird in 3 Kind-Dreiecke unterteilt und auf jedem Kind-Dreieck ist die interpolierte Funktion ein kubisches Polynom der 2 Koordinaten). Diese Technik stammt aus der FEM-Analyse (Finite-Elemente-Methode); das verwendete Element ist ein reduziertes Hsieh-Clough-Tocher (HCT)-Element. Seine Formfunktionen sind in [1] beschrieben. Die zusammengefügte Funktion ist garantiert C1-glatt, d.h. sie ist stetig und ihre ersten Ableitungen sind ebenfalls stetig (dies lässt sich leicht innerhalb der Dreiecke zeigen, ist aber auch beim Überqueren der Kanten der Fall).

Im Standardfall (*kind* = 'min_E') werden die Ableitungen an jedem Knoten so berechnet, dass sie eine Krümmungsenergie im Funktionsraum minimieren, der von den HCT-Element-Formfunktionen erzeugt wird – mit auferlegten Werten, aber beliebigen Ableitungen an jedem Knoten. Die minimierte Funktion ist das Integral der sogenannten Gesamtkrümmung (Implementierung basiert auf einem Algorithmus aus [2] - PCG Sparse Solver)

\[E(z) = \frac{1}{2} \int_{\Omega} \left( \left( \frac{\partial^2{z}}{\partial{x}^2} \right)^2 + \left( \frac{\partial^2{z}}{\partial{y}^2} \right)^2 + 2\left( \frac{\partial^2{z}}{\partial{y}\partial{x}} \right)^2 \right) dx\,dy\]

Wenn der Fall *kind* = 'geom' vom Benutzer gewählt wird, wird eine einfache geometrische Näherung verwendet (gewichteter Durchschnitt der Dreiecksnormale), was auf sehr großen Gittern zu einer Verbesserung der Geschwindigkeit führen kann.

Referenzen

[1]

Michel Bernadou, Kamal Hassan, "Basisfunktionen für allgemeine Hsieh-Clough-Tocher-Dreiecke, vollständig oder reduziert.", International Journal for Numerical Methods in Engineering, 17(5):784 - 789. 2.01.

[2]

C.T. Kelley, "Iterative Methods for Optimization".

gradient(x, y)

Gibt eine Liste von 2 Maskenarrays zurück, die interpolierte Ableitungen an den angegebenen (x, y)-Punkten enthalten.

Parameter:

x, yarray-ähnlich

x- und y-Koordinaten gleicher Form und beliebiger Dimensionalität.

Gibt zurück:

dzdx, dzdynp.ma.array

2 Maskenarrays mit der gleichen Form wie *x* und *y*; Werte, die zu (x, y)-Punkten außerhalb der Triangulation gehören, sind maskiert. Das erste zurückgegebene Array enthält die Werte von \(\frac{\partial z}{\partial x}\) und das zweite die Werte von \(\frac{\partial z}{\partial y}\).

class matplotlib.tri.TriRefiner(triangulation)

Abstrakte Basisklasse für Klassen, die die Netzverfeinerung implementieren.

Ein TriRefiner kapselt ein Triangulationsobjekt und bietet Werkzeuge zur Netzverfeinerung und Interpolation.

Abgeleitete Klassen müssen implementieren

• refine_triangulation(return_tri_index=False, **kwargs), wobei die optionalen Schlüsselwort-Argumente *kwargs* in jeder konkreten TriRefiner-Implementierung definiert sind und was zurückgibt

  • eine verfeinerte Triangulation,

  • optional (abhängig von *return_tri_index*), für jeden Punkt der verfeinerten Triangulation: den Index des ursprünglichen Triangulationsdreiecks, zu dem er gehört.

• refine_field(z, triinterpolator=None, **kwargs), wobei

  • z ein Array von Feldwerten (zu verfeinern), das an den Knoten der Basis-Triangulation definiert ist,

  • triinterpolator ein optionaler TriInterpolator ist,

  • die anderen optionalen Schlüsselwort-Argumente *kwargs* in jeder konkreten TriRefiner-Implementierung definiert sind;

  und was zurückgibt (als Tupel) ein verfeinertes Dreiecksnetz und die interpolierten Werte des Feldes an den Knoten der verfeinerten Triangulation.

class matplotlib.tri.UniformTriRefiner(triangulation)

Bases: TriRefiner

Gleichmäßige Netzverfeinerung durch rekursive Unterteilungen.

Parameter:

triangulationTriangulation

Die gekapselte Triangulation (zu verfeinern)

refine_field(z, triinterpolator=None, subdiv=3)

Verfeinert ein Feld, das auf den gekapselten Triangulationsknoten definiert ist.

Parameter:

z(npoints,) array-ähnlich

Werte des zu verfeinernden Feldes, die an den Knoten der gekapselten Triangulation definiert sind. (*n_points* ist die Anzahl der Punkte in der ursprünglichen Triangulation)

triinterpolatorTriInterpolator, optional

Interpolator, der für die Feldinterpolation verwendet wird. Wenn nicht angegeben, wird ein CubicTriInterpolator verwendet.

subdivint, Standard: 3

Rekursionsstufe für die Unterteilung. Jedes Dreieck wird in 4**subdiv Kind-Dreiecke unterteilt.

Gibt zurück:

refi_triTriangulation

Die zurückgegebene verfeinerte Triangulation.

refi_z1D-Array der Länge: *refi_tri* Knotenanzahl.

Das zurückgegebene interpolierte Feld (an den *refi_tri*-Knoten).

refine_triangulation(return_tri_index=False, subdiv=3)

Berechnet eine gleichmäßig verfeinerte Triangulation *refi_triangulation* der gekapselten triangulation.

Diese Funktion verfeinert die gekapselte Triangulation, indem sie jedes Eltern-Dreieck in 4 Kind-Unterdreiecke unterteilt, die auf den Mittelpunkten der Kanten basieren, und dies *subdiv*-mal wiederholt. Am Ende wird jedes Dreieck in 4**subdiv Kind-Dreiecke unterteilt.

Parameter:

return_tri_indexbool, Standard: False

Gibt an, ob eine Indextabelle zurückgegeben wird, die den Index des Vaterdreiecks für jeden Punkt angibt.

subdivint, Standard: 3

Rekursionsstufe für die Unterteilung. Jedes Dreieck wird in 4**subdiv Kind-Dreiecke unterteilt; daher führt die Standardeinstellung zu 64 verfeinerten Unterdreiecken für jedes Dreieck der ursprünglichen Triangulation.

Gibt zurück:

refi_triangulationTriangulation

Die verfeinerte Triangulation.

found_indexint array

Index der ursprünglichen Triangulation, die das Dreieck enthält, für jeden Punkt von *refi_triangulation*. Wird nur zurückgegeben, wenn *return_tri_index* auf True gesetzt ist.

class matplotlib.tri.TriAnalyzer(triangulation)

Definiert grundlegende Werkzeuge für die Analyse und Verbesserung von Dreiecksgittern.

Ein TriAnalyzer kapselt ein Triangulation-Objekt und bietet grundlegende Werkzeuge für die Gitteranalyse und -verbesserung.

Parameter:

triangulationTriangulation

Die eingekapselte Triangulation zur Analyse.

Attribute:

scale_factors

Faktoren zur Skalierung der Triangulation in ein Einheitsquadrat.

circle_ratios(rescale=True)

Gibt ein Maß für die Flachheit der Dreiecke der Triangulation zurück.

Das Verhältnis des Radius des Inkreises zum Radius des Umkreises ist ein weit verbreitter Indikator für die Flachheit eines Dreiecks. Es ist immer <= 0.5 und == 0.5 nur für gleichseitige Dreiecke. Kreisverhältnisse unter 0,01 bezeichnen sehr flache Dreiecke.

Um unbillig niedrige Werte aufgrund von Skalierungsunterschieden zwischen den beiden Achsen zu vermeiden, kann das Dreiecksgitter zuerst skaliert werden, um in ein Einheitsquadrat mit scale_factors zu passen (nur wenn rescale True ist, was sein Standardwert ist).

Parameter:

rescalebool, Standard: True

Wenn True, intern skalieren (basierend auf scale_factors), so dass die (unmaskierten) Dreiecke genau in ein Einheitsgitter passen.

Gibt zurück:

maskiertes Array

Verhältnis des Inkreisradius zum Umkreisradius für jedes 'reskalierte' Dreieck der eingekapselten Triangulation. Werte, die maskierten Dreiecken entsprechen, werden maskiert.

get_flat_tri_mask(min_circle_ratio=0.01, rescale=True)

Entfernt übermäßig flache Randdreiecke aus der Triangulation.

Gibt eine Maske new_mask zurück, die es ermöglicht, die eingekapselte Triangulation von ihren Rand-flachen Dreiecken (gemäß ihren circle_ratios()) zu bereinigen. Diese Maske soll anschließend mit Triangulation.set_mask auf die Triangulation angewendet werden. new_mask ist eine Erweiterung der ursprünglichen Triangulationsmaske in dem Sinne, dass ein ursprünglich maskiertes Dreieck maskiert bleibt.

Das new_mask-Array wird rekursiv berechnet; in jedem Schritt werden flache Dreiecke nur entfernt, wenn sie eine Seite mit dem aktuellen Gitterrand teilen. Dadurch werden keine neuen Löcher im triangulierten Gebiet erzeugt.

Parameter:

min_circle_ratiofloat, Standard: 0.01

Randdreiecke mit dem Verhältnis der Radien von Inkreis und Umkreis r/R werden entfernt, wenn r/R < min_circle_ratio.

rescalebool, Standard: True

Wenn True, wird zunächst intern skaliert (basierend auf scale_factors), so dass die (unmaskierten) Dreiecke genau in ein Einheitsquadrat passen. Diese Skalierung berücksichtigt den möglicherweise vorhandenen Unterschied in der Skalierung zwischen den beiden Achsen.

Gibt zurück:

Array von bool

Maske zum Anwenden auf die eingekapselte Triangulation. Alle ursprünglich maskierten Dreiecke bleiben in new_mask maskiert.

Anmerkungen

Die Begründung für diese Funktion ist, dass eine Delaunay-Triangulation – eines unstrukturierten Punktesatzes – manchmal fast flache Dreiecke am Rand enthält, was zu Artefakten in Diagrammen (insbesondere bei hochauflösenden Konturen) führt. Mit der berechneten new_mask maskiert, würde die eingekapselte Triangulation keine unmaskierten Randdreiecke mehr mit einem Kreisverhältnis unter min_circle_ratio enthalten, wodurch die Gitterqualität für nachfolgende Diagramme oder Interpolationen verbessert wird.

property scale_factors

Faktoren zur Skalierung der Triangulation in ein Einheitsquadrat.

Gibt zurück:

(float, float)

Skalierungsfaktoren (kx, ky), so dass die Triangulation [triangulation.x * kx, triangulation.y * ky] genau in ein Einheitsquadrat passt.