Discussion :

[tabkelm]

bonjour,

Je cherche un code en python grâce auquel en entrant:
-une liste de points 2D ou 3D
-le vecteur vitesse en chacun de ces points
-les courbures en chacun de ces points
-le vecteur accélération tangentielle en chacun de ces points

fournit:
1) l'équation paramétrique de la courbe construite avec ces données sachant qu'en chacun de ces points,la vitesse et l'accélération tangentielle y seront appropriées.
2)l'équation paramétrique de la surface passant par chacun de ces points

Le cas 1) me suffirait


merci de votre aide





merci de votre aide

[robinechuca]

Si vous voulez vous contenter d'une solution fausse mais pas trop non plus, regarder du coté des interpolations.
Si vous voulez une solution exacte, vous pouvez le faire a la main en calculant des polynôme d'ordre n avec n qu'on va voir juste après.
1) déjà, il me semble que l'un de vos paramètre d’entrée est redondant, si vous connaissez l'accélération tangentiel et la vitesse, vous pouvez en déduire le rayon de courbure...
Donc pour la suite, je vais complètement faire abstraction du rayon et du point de courbure.

Déjà, vous pouvez vous simplifier la vie en projetant sur chacun des axes en prenant comme équation paramétrique:

position_paramétrique(t) = (position_x(t), position_y(t), position_z(t))

donc la question maintenant c'est comment on calcul position_x(t) (si on sait faire ça c'est bon car après c'est pareil pour les autres)

L'une des solutions (mais elle est loin d’être unique), c'est de prendre position_x(t) comme un polynôme en t.

Il faut ensuite poser les équations:
-Il existe t1 tel que position_x(t1) = point1_x, et position_x'(t1) = vitesse_x(t1), et position_x''(t1) = acceleration_x(t1)
- ...

On se rend compte qu'a chaque point, il y a 3 contraintes, il vous faut donc prendre n = 3*nombre_de_points, affin d'avoir pile le bon degrés de liberté pour que ce système soit relevable.

2) peut être serait-il judicieux de rajouter en entrée une liste qui comporte, l'instant de chacun de ces points, affin que l'on puisse connaître en avance (t1, t2, ...), l'avantage c'est qu'en les connaissant, le système devient linéaire
et donc on est capable de le résoudre très facilement. (scipy, numpy le font sûrement très efficacement (bien qu'on puisse aussi le recoder a la main, c'est pas très violant))
Par contre, si vous connaissez pas les instants t1, t2, il va falloir résoudre un système pas du tout linéaire, et la ça devient compliqué...
Ceci dit, si vraiment vous tenez a ne pas connaître en avance t1, t2 ..., vous pouvez toujours les fixer arbitrairement, faire le calcul de la trajectoire, les recorriger un peu, refaire le calcul et ainsi de suite.

3) je comprend pas votre histoire de surface... si c'est pour faire un maillage matplotlib.trisurf sans sort pas trop mal mais il ne renvoi pas une équation paramétrique.

[tabkelm]

1)pour déterminer le polynôme en t de degré n=3*nombre_de_points, une interpolation d'Hermite d'ordre 3 est nécessaire.
J'ai trouvé ce script pour Matlab :
https://codetobuy.com/downloads/herm...of-high-order/
A se demander si d'après les exemples de cette page,les ordonnées de chaque point sont nécessairement l'image par une fonction définie(iciy=exp(x) et y=x^8+1 ) de leur abscisse et non(ce que je souhaite) dessinés selon un choix à main levée

3) si avec une équation paramétrique comportant 2 paramètres distincts u et v
x(u,v)=fonction1(u,v)
y(u,v)=fonction2(u,v)
z(u,v)=fonction3(u,v)

[danielhagnoul]

Vous n'avez pas beaucoup cherché ou alors pas au bon endroit, voici un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#! python3
# coding: utf-8
 
import numpy as np
import matplotlib.pyplot as plt
 
plt.title("Équation paramétrique y(t)")
plt.xlabel("x_data")
plt.ylabel("y_data")
 
x_data = np.array([1, 2, 3, 4, 5])
y_data = np.array([2, 0, 3, 7, 13])
plt.scatter(x_data, y_data, s=20, c="red", label="data")
 
y_params = np.polyfit(x_data, y_data, 3)  # équation de degré 3
y = np.poly1d(y_params)
t = np.linspace(min(x_data), max(x_data), 100)
plt.plot(t, y(t), c="lightblue", label="y(t)")
 
plt.legend()
plt.grid()
plt.show()

Autre exemple avec un choix d'équation et curve-fit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#! python3
# coding: utf-8
 
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
 
def func(x, a, b):
    """ Choix de l'équation ?
    Voir : https://www.md.ucl.ac.be/tutorial/tutorial/didacphys/rappels/math/fonctions/expon.html
    """
    return a * (1.0 - np.exp(-b * x))
 
 
""" Générer les données x, y """
x = np.linspace(0, 3, 100)
y = func(x, 3, 2)
 
plt.plot(x, y, color="yellow", label="func(x,3,2)")
 
""" Ajouter du bruit (Gaussian distribution) 
pour simuler les données expérimentales.
"""
noise = 0.2 * np.random.normal(size=y.size)
y_noise = y + noise
 
plt.scatter(x, y_noise, s=5, c="red", label="y_noise")
 
""" Curve Fit """
init_vals = [1, 1]  # for [a, b]
best_vals, covar = curve_fit(func, x, y_noise, p0=init_vals)
print('best_vals: {}'.format(best_vals))  # best_vals: [2.96412058 2.05106931]
 
y_fit = func(x, best_vals[0], best_vals[1])
plt.plot(x, y_fit, label="y_fit")  # très proche de la courbe func(x, 3, 2)
 
plt.legend()
plt.show()

[tabkelm]

merci pour les exemples de code.

Pour le premier code,j'obtiens un polynôme de degré 3.
Mais si j'avais entré des valeurs supplémentaires:
y'_date
y''_data
j'aurai besoin d'un polynôme P de degré 3x3 satisfaisant en plus
P('x_data)=y'_data
P''(x_data)=y"_data
Alors,quelle instruction python du genre;
y_params = np.polyfit(x_data, y_data, y'_data,y"_data,9)
peut faire l'affaire?

[danielhagnoul]

polyfit, voir la doc : https://numpy.org/doc/stable/referen...numpy.polyfitl

polyid, voir la doc : https://numpy.org/doc/stable/referen...l#numpy.poly1d

Le degré de l'équation c'est vous qui le déterminer par essai successif de 2 à n.

La taille des données (x, y) est quelconque, le principe de calcul reste le même.

Si vous avez plusieurs jeux de données (x, y), vous devez traiter chaque jeu indépendamment des autres.