Kernel lisse ensemble de tuplets xyz (pseudo préférablement python bienvenus)

Question

Je voudrais lisser un ensemble de 0pluscules xyz dans une surface et de renvoyer la valeur de surface(z') à l'ensemble initial de coordonnées (x,y).

Existe-t-il une approche plus directe, puis interpoler les données d'origine sur une grille, les lisser et les réévaluer. Si c'est la meilleure approche, existe-t-il des fonctionnalités spécifiques à Python que les gens aiment/sont la norme?

Par exemple:

(x1,y1,z1) -> (x1,y1,z1') 
(x2,y2,z2) -> (x2,y2,z2') 
(x3,y3,z3) -> (x3,y3,z3') 
(x4,y4,z4) -> (x4,y4,z4') 

Answer 1

"Lissage" est pas une opération bien définie; ce que cela signifie est ouvert à l'interprétation. Il y a beaucoup d'opérations qui donnent des données "plus lisses", et la plupart d'entre elles ont au moins un paramètre qui contrôle la quantité de lissage. Sans en savoir plus sur ce que vous allez faire avec les données lissées, il est difficile de donner une réponse définitive à cette question.

Voici une réponse quand même. :)

scipy.interpolate.Rbf est un interpolateur pour les données n-dimensionnelles qui inclut un paramètre de lissage. Lorsque ce paramètre est 0 (qui est la valeur par défaut), un véritable interpolateur est créé, c'est-à-dire qu'il renvoie les valeurs z données aux valeurs (x, y) données et, à d'autres points, renvoie les valeurs z interpolées. Rbf inclut un paramètre smooth à propos duquel le docstring dit "Les valeurs supérieures à zéro augmentent la fluidité de l'approximation".

Ainsi, une réponse à votre question qui utilise Rbf est:.

f = Rbf(x, y, z, smooth=<a positive number>) 
z_smoothed = f(x, y) 

(Malheureusement, le Rbf docstring n'explique pas comment smooth est utilisé Il faudrait creuser dans le code pour savoir En attendant, vous pouvez essayer quelques valeurs et voir si les résultats répondent à vos besoins.)

Le script suivant est un exemple d'utilisation de Rbf avec un argument non nul smooth. Les points d'entrée et la surface lissée sont tracés en utilisant matplotlib.

import numpy as np 
from scipy.interpolate import Rbf 

import matplotlib.pyplot as plt 
from mpl_toolkits.mplot3d import Axes3D 


# Generate some random (x, y, z) values. 
npoints = 36 
np.random.seed(12345) 
x, y = np.random.rand(2, npoints) 
z = np.cos(3*x)*np.sin(2*y) + 0.4*np.random.randn(npoints) 


# "Interpolator" with smoothing 
f = Rbf(x, y, z, smooth=0.05) 

print("Original z values:") 
print(z) 
print("Smoothed z values:") 
print(f(x, y)) 

u = np.linspace(0, 1, 25) 
xx, yy = np.meshgrid(u, u) 
zz = f(xx, yy) 

fig = plt.figure() 
ax = fig.add_subplot(111, projection='3d') 
ax.scatter(x, y, z) 

surf1 = ax.plot_surface(xx, yy, zz, rstride=1, cstride=1, color='g', 
         linewidth=0, antialiased=False, alpha=0.5) 

plt.show() 

Le script génère le tracé suivant. Les points bleus sont les données d'origine et la surface verte est le graphique de la fonction créée par Rbf.

Les impressions de script:

Original z values: 
[-0.34127933 -0.30729404 0.21155127 0.82107652 0.17163933 -0.44447561 
-0.62316986 -0.07631452 -0.2452825 0.08006371 -0.16038592 -1.15094797 
    0.97879369 -0.59069121 0.28481385 -0.61505364 -1.28958296 -0.40040525 
-0.62065409 0.10887611 0.11082111 -0.57756184 -0.08303365 0.1736536 
-0.11741524 -0.25279036 -0.87523777 -0.62589892 0.14774674 1.02822874 
    1.40065013 0.0570847 -1.24442082 1.29216089 0.04075983 0.35829967] 
Smoothed z values: 
[-0.4760952 -0.32638375 0.33082556 0.81805681 0.04136433 -0.04617472 
-0.6941891 -0.17280308 -0.21626414 -0.25286811 -0.19661876 -1.04547018 
    1.19599927 -0.55479106 0.3257578 -0.35879233 -0.9914419 -0.74646378 
-0.60559207 -0.11546096 -0.10684431 -0.35038102 0.05290993 0.10818459 
-0.07302746 -0.33240211 -0.82955756 -0.32360917 0.11565045 0.98144511 
    1.22421926 -0.08092414 -0.97381114 1.16754806 0.01186976 0.11594726]