scipy.interpolate.

make_splprep

scipy.interpolate.make_splprep(x, *, w=None, u=None, ub=None, ue=None, k=3, s=0, t=None, nest=None)

Erstellt eine glättende parametrische B-Spline-Kurve mit begrenztem Fehler, die Sprünge in den Ableitungen minimiert.

Gegeben ist eine Liste von N 1D-Arrays, x, die eine Kurve im N-dimensionalen Raum darstellen, parametrisiert durch u. Gesucht ist eine glatte approximierende Spline-Kurve g(u).

Parameter:

xarray_like, Form (m, ndim)

Abgetastete Datenpunkte, die die Kurve in ndim Dimensionen darstellen. Typischerweise wird dies als Liste von 1D-Arrays der Länge m verwendet.

warray_like, Form (m,), optional

Ein rein positives 1D-Array von Gewichten. Die Gewichte werden bei der Berechnung der gewichteten Spline-Anpassung nach kleinsten Quadraten verwendet. Wenn die Fehler in den x-Werten die Standardabweichung d aufweisen, dann sollten w gleich 1/d sein. Standardwert ist np.ones(m).

uarray_like, optional

Ein Array von Parameterwerten für die Kurve in parametrischer Form. Wenn nicht angegeben, werden diese Werte automatisch gemäß

v[0] = 0
v[i] = v[i-1] + distance(x[i], x[i-1])
u[i] = v[i] / v[-1]

ub, uefloat, optional

Die Endpunkte des Parameterintervalls. Standardwert ist u[0] und u[-1].

kint, optional

Grad der Spline. Kubische Splines, k=3, werden empfohlen. Gerade Werte von k sollten insbesondere bei kleinen s-Werten vermieden werden. Standardwert ist k=3

sfloat, optional

Eine Glättungsbedingung. Das Maß der Glättung wird durch die Erfüllung der Bedingungen bestimmt

sum((w * (g(u) - x))**2) <= s,

wobei g(u) die geglättete Approximation an x ist. Der Benutzer kann s verwenden, um den Kompromiss zwischen Nähe und Glattheit der Anpassung zu steuern. Größere s-Werte bedeuten mehr Glättung, während kleinere s-Werte weniger Glättung anzeigen. Empfohlene Werte für s hängen von den Gewichten w ab. Wenn die Gewichte das Inverse der Standardabweichung von x darstellen, dann sollte ein guter s-Wert im Bereich (m - sqrt(2*m), m + sqrt(2*m)) liegen, wobei m die Anzahl der Datenpunkte in x und w ist.

tarray_like, optional

Die Spline-Knoten. Wenn None (Standard), werden die Knoten automatisch konstruiert. Es müssen mindestens 2*k + 2 und höchstens m + k + 1 Knoten vorhanden sein.

nestint, optional

Die Ziel-Länge des Knotenvektors. Sollte zwischen 2*(k + 1) (die minimale Anzahl von Knoten für eine Spline vom Grad k) und m + k + 1 (die Anzahl der Knoten der interpolierenden Spline) liegen. Die tatsächliche Anzahl der von dieser Routine zurückgegebenen Knoten kann etwas größer als nest sein. Standardwert ist None (keine Begrenzung, bis zu m + k + 1 Knoten hinzufügen).

Rückgabe:

splein BSpline Instanz

Für s=0 gilt spl(u) == x. Für nicht-null s-Werte repräsentiert spl die geglättete Approximation an x, im Allgemeinen mit weniger Knoten.

undarray

Die Parameterwerte

Siehe auch

generate_knots

wird intern für die Generierung der Knoten verwendet

make_splrep

das Analogon dieser Routine für 1D-Funktionen

make_interp_spline

Erstellung einer interpolierenden Spline (s = 0)

make_lsq_spline

Erstellung der Spline nach der Methode der kleinsten Quadrate unter Verwendung des gegebenen Knotenvektors

splprep

ein FITPACK-Analogon dieser Routine

Hinweise

Gegeben sind \(m\) Datenpunkte im \(D\)-dimensionalen Raum, \(\vec{x}_j\), mit \(j=1, ..., m\) und \(\vec{x}_j = (x_{j; 1}, ..., x_{j; D})\). Diese Routine konstruiert die parametrische Spline-Kurve \(g_a(u)\) mit \(a=1, ..., D\), um die Summe der Sprünge, \(D_{i; a}\), der k-ten Ableitung an den internen Knoten (\(u_b < t_i < u_e\)) zu minimieren, wobei

\[D_{i; a} = g_a^{(k)}(t_i + 0) - g_a^{(k)}(t_i - 0)\]

Speziell konstruiert die Routine die Spline-Funktion \(g(u)\), die Folgendes minimiert:

\[\sum_i \sum_{a=1}^D | D_{i; a} |^2 \to \mathrm{min}\]

vorausgesetzt, dass

\[\sum_{j=1}^m \sum_{a=1}^D (w_j \times (g_a(u_j) - x_{j; a}))^2 \leqslant s\]

wobei \(u_j\) der Parameterwert ist, der dem Datenpunkt \((x_{j; 1}, ..., x_{j; D})\) entspricht, und \(s > 0\) der Eingabeparameter ist.

Mit anderen Worten, wir balancieren die Maximierung der Glattheit (gemessen als Sprünge der Ableitung, das erste Kriterium) und die Abweichung von \(g(u_j)\) von den Daten \(x_j\) (das zweite Kriterium).

Beachten Sie, dass die Summation im zweiten Kriterium über alle Datenpunkte und im ersten Kriterium über die internen Spline-Knoten (d.h. diejenigen mit ub < t[i] < ue) erfolgt. Die Spline-Knoten sind im Allgemeinen eine Teilmenge der Daten. Weitere Einzelheiten finden Sie unter generate_knots.

Hinzugefügt in Version 1.15.0.

Referenzen

[1]

P. Dierckx, “Algorithms for smoothing data with periodic and parametric splines, Computer Graphics and Image Processing”, 20 (1982) 171-184.

[2]

P. Dierckx, “Curve and surface fitting with splines”, Monographs on Numerical Analysis, Oxford University Press, 1993.