Gładka reprezentacja splajnu dowolnego konturu, f (długość) -> x, y

Question

Załóżmy, że mam zestaw współrzędnych x, y, które zaznaczają punkty wzdłuż konturu. Czy istnieje sposób, w jaki mogę zbudować reprezentację konturu krzywej, którą mogę ocenić w określonej pozycji wzdłuż jej długości i odzyskać interpolowane współrzędne X, Y?

Często nie jest tak, że istnieje zgodność 1: 1 między wartościami X i Y, więc jednowymiarowe splajny nie są dla mnie dobre. Warianty dwuwymiarowe byłyby w porządku, ale o ile mogę powiedzieć, wszystkie funkcje do oceny binarnych splajnów w scipy.interpolate pobierają x, y wartości i zwracają z, podczas gdy ja muszę podać z i zwracać x, y (ponieważ x, y to punkty na linii każdy z mapuje na unikalny x, y).

Oto szkic tego, co chciałbym być w stanie to zrobić:

import numpy as np 
from matplotlib.pyplot import plot 

# x,y coordinates of contour points, not monotonically increasing 
x = np.array([ 2., 1., 1., 2., 2., 4., 4., 3.]) 
y = np.array([ 1., 2., 3., 4., 2., 3., 2., 1.]) 

# f: X --> Y might not be a 1:1 correspondence 
plot(x,y,'-o') 

# get the cumulative distance along the contour 
dist = [0] 
for ii in xrange(x.size-1): 
    dist.append(np.sqrt((x[ii+1]-x[ii])**2 + (y[ii+1]-y[ii])**2)) 
d = np.array(dist) 

# build a spline representation of the contour 
spl = ContourSpline(x,y,d) 

# resample it at smaller distance intervals 
interp_d = np.linspace(d[0],d[-1],1000) 
interp_x,interp_y = spl(interp_d) 

Answer 1

Chcesz używać parametrycznego splajn, gdzie zamiast interpolację y od wartości x, skonfigurować nowy parametr , t i interpoluj zarówno y i x z wartości t, używając jednowymiarowych splajnów dla obu. Jak przypisać t wartości każdego punktu wpływa na wynik, a przy użyciu dystansu, jak Twoje pytanie sugeruje, może być dobrym pomysłem:

from __future__ import division 
import numpy as np 
import matplotlib.pyplot as plt 
import scipy.interpolate 

x = np.array([ 2., 1., 1., 2., 2., 4., 4., 3.]) 
y = np.array([ 1., 2., 3., 4., 2., 3., 2., 1.]) 
plt.plot(x,y, label='poly') 

t = np.arange(x.shape[0], dtype=float) 
t /= t[-1] 
nt = np.linspace(0, 1, 100) 
x1 = scipy.interpolate.spline(t, x, nt) 
y1 = scipy.interpolate.spline(t, y, nt) 
plt.plot(x1, y1, label='range_spline') 

t = np.zeros(x.shape) 
t[1:] = np.sqrt((x[1:] - x[:-1])**2 + (y[1:] - y[:-1])**2) 
t = np.cumsum(t) 
t /= t[-1] 
x2 = scipy.interpolate.spline(t, x, nt) 
y2 = scipy.interpolate.spline(t, y, nt) 
plt.plot(x2, y2, label='dist_spline') 

plt.legend(loc='best') 
plt.show() 

Answer 2

Można użyć splprep i splev, zajrzyj w scipy cookbook na przykład bardzo podobny do twojego problemu.

http://wiki.scipy.org/Cookbook/Interpolation#head-34818696f8d7066bb3188495567dd776a451cf11

Answer 3

Oto przykład przy użyciu splprep i splev:

import numpy as np 
import scipy.interpolate 
from matplotlib.pyplot import plot 

# x,y coordinates of contour points, not monotonically increasing 
x = np.array([2., 1., 1., 2., 2., 4., 4., 3.]) 
y = np.array([1., 2., 3., 4., 2., 3., 2., 1.]) 

# f: X --> Y might not be a 1:1 correspondence 
plot(x, y, '-o') 

# get the cumulative distance along the contour 
dist = np.sqrt((x[:-1] - x[1:])**2 + (y[:-1] - y[1:])**2) 
dist_along = np.concatenate(([0], dist.cumsum())) 

# build a spline representation of the contour 
spline, u = scipy.interpolate.splprep([x, y], u=dist_along, s=0) 

# resample it at smaller distance intervals 
interp_d = np.linspace(dist_along[0], dist_along[-1], 50) 
interp_x, interp_y = scipy.interpolate.splev(interp_d, spline) 
plot(interp_x, interp_y, '-o')