`matplotlib.bezier`#

Ein Modul, das einige Hilfsfunktionen zur Manipulation von Bézier-Pfaden bereitstellt.

class matplotlib.bezier.BezierSegment(control_points)[Quelle]#

Bases: object

Ein d-dimensionales Bézier-Segment.

Parameter:

control_points(N, d) Array: Position der N Kontrollpunkte.

axis_aligned_extrema()[Quelle]#

Gibt die Dimension und Position der inneren Extrema der Kurve zurück.

Die Extrema sind die Punkte auf der Kurve, an denen eine ihrer partiellen Ableitungen null ist.

Gibt zurück:

dimsArray von int: Index \(i\) der partiellen Ableitung, die bei jedem inneren Extremum null ist.
dzerosArray von float: Von gleicher Größe wie dims. Das \(t\), so dass \(d/dx_i B(t) = 0\)

property control_points#: Die Kontrollpunkte der Kurve.

property degree#: Grad des Polynoms. Einer weniger als die Anzahl der Kontrollpunkte.

property dimension#: Die Dimension der Kurve.

point_at_t(t)[Quelle]#: Evaluiert die Kurve an einem einzelnen Punkt und gibt ein Tupel von d Floats zurück.

property polynomial_coefficients#

Die Polynomkoeffizienten der Bézier-Kurve.

Warnung

Folgt der entgegengesetzten Konvention von numpy.polyval.

Gibt zurück:

(n+1, d) Array: Koeffizienten nach der Entwicklung in Polynombasis, wobei \(n\) der Grad der Bézier-Kurve und \(d\) ihre Dimension ist. Dies sind die Zahlen (\(C_j\)), so dass die Kurve geschrieben werden kann als \(\sum_{j=0}^n C_j t^j\).

Anmerkungen

Die Koeffizienten werden berechnet als

\[{n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i\]

wobei \(P_i\) die Kontrollpunkte der Kurve sind.

exception matplotlib.bezier.NonIntersectingPathException[Quelle]#: Bases: ValueError

matplotlib.bezier.check_if_parallel(dx1, dy1, dx2, dy2, tolerance=1e-05)[Quelle]#

Prüft, ob zwei Linien parallel sind.

Parameter:

dx1, dy1, dx2, dy2float: Die Gradienten dy/dx der beiden Linien.
tolerancefloat: Die Winkeltoleranz in Radiant, bis zu der die Linien als parallel gelten.

Gibt zurück:

is_parallel

1, wenn zwei Linien in gleicher Richtung parallel sind.
-1, wenn zwei Linien in entgegengesetzter Richtung parallel sind.
False andernfalls.

matplotlib.bezier.find_bezier_t_intersecting_with_closedpath(bezier_point_at_t, inside_closedpath, t0=0.0, t1=1.0, tolerance=0.01)[Quelle]#

Findet den Schnittpunkt der Bézier-Kurve mit einem geschlossenen Pfad.

Der Schnittpunkt t wird durch zwei Parameter t0, t1 approximiert, so dass t0 <= t <= t1.

Die Suche beginnt bei t0 und t1 und verwendet einen einfachen Bisektionsalgorithmus. Daher muss einer der Endpunkte innerhalb des Pfades liegen, während der andere dies nicht tut. Die Suche stoppt, wenn die Distanz der durch t0 und t1 parametrisierten Punkte kleiner als die angegebene tolerance wird.

Parameter:

bezier_point_at_tcallable

Eine Funktion, die die x, y Koordinaten des Béziers bei Parameter t zurückgibt. Sie muss die Signatur

bezier_point_at_t(t: float) -> tuple[float, float]

inside_closedpathcallable

Eine Funktion, die True zurückgibt, wenn ein gegebener Punkt (x, y) innerhalb des geschlossenen Pfades liegt. Sie muss die Signatur

inside_closedpath(point: tuple[float, float]) -> bool

t0, t1float

Startparameter für die Suche.

tolerancefloat

Maximal erlaubte Distanz zwischen den Endpunkten.

Gibt zurück:

t0, t1float: Die Bézier-Pfadparameter.

matplotlib.bezier.find_control_points(c1x, c1y, mmx, mmy, c2x, c2y)[Quelle]#: Findet die Kontrollpunkte der Bézier-Kurve, die durch (c1x, c1y), (mmx, mmy) und (c2x, c2y) bei den parametrischen Werten 0, 0.5 und 1 verläuft.

matplotlib.bezier.get_cos_sin(x0, y0, x1, y1)[Quelle]#

matplotlib.bezier.get_intersection(cx1, cy1, cos_t1, sin_t1, cx2, cy2, cos_t2, sin_t2)[Quelle]#: Gibt den Schnittpunkt zwischen der Linie durch (cx1, cy1) im Winkel t1 und der Linie durch (cx2, cy2) im Winkel t2 zurück.

matplotlib.bezier.get_normal_points(cx, cy, cos_t, sin_t, length)[Quelle]#: Für eine Linie, die durch (cx, cy) verläuft und den Winkel t hat, werden die Positionen der beiden Punkte zurückgegeben, die sich entlang ihrer Senkrechten im Abstand von length befinden.

matplotlib.bezier.get_parallels(bezier2, width)[Quelle]#: Gegeben die quadratischen Bézier-Kontrollpunkte bezier2, gibt diese Funktion die Kontrollpunkte von quadratischen Bézier-Linien zurück, die ungefähr parallel zu den gegebenen Linien sind und durch width getrennt werden.

matplotlib.bezier.inside_circle(cx, cy, r)[Quelle]#

Gibt eine Funktion zurück, die prüft, ob ein Punkt in einem Kreis mit Zentrum (cx, cy) und Radius r liegt.

Die zurückgegebene Funktion hat die Signatur

f(xy: tuple[float, float]) -> bool

matplotlib.bezier.make_wedged_bezier2(bezier2, width, w1=1.0, wm=0.5, w2=0.0)[Quelle]#: Ähnlich wie get_parallels gibt diese Funktion die Kontrollpunkte von zwei quadratischen Bézier-Linien zurück, die eine ungefähr parallele Breite zum gegebenen haben und durch width getrennt sind.

matplotlib.bezier.split_bezier_intersecting_with_closedpath(bezier, inside_closedpath, tolerance=0.01)[Quelle]#

Teilt eine Bézier-Kurve an der Schnittstelle mit einem geschlossenen Pfad in zwei Teile.

Parameter:

bezier(N, 2) array-ähnlich: Kontrollpunkte des Bézier-Segments. Siehe BezierSegment.
inside_closedpathcallable: Eine Funktion, die True zurückgibt, wenn ein gegebener Punkt (x, y) innerhalb des geschlossenen Pfades liegt. Siehe auch find_bezier_t_intersecting_with_closedpath.
tolerancefloat: Die Toleranz für die Schnittmenge. Siehe auch find_bezier_t_intersecting_with_closedpath.

Gibt zurück:

links, rechts: Listen von Kontrollpunkten für die beiden Bézier-Segmente.

matplotlib.bezier.split_de_casteljau(beta, t)[Quelle]#: Teilt ein Bézier-Segment, das durch seine Kontrollpunkte beta definiert ist, in zwei separate Segmente, die bei t geteilt werden, und gibt deren Kontrollpunkte zurück.

matplotlib.bezier.split_path_inout(path, inside, tolerance=0.01, reorder_inout=False)[Quelle]#: Teilt einen Pfad an der Stelle, an der inside(x, y) falsch wird, in zwei Segmente.

matplotlib.bezier#

`matplotlib.bezier`#