mouvement aleatoire d'un point (python)

[Yosh2]

bonsoir
j'aimerais simuler le mouvement aléatoire d'un point sur python, en effet j'aimerais que le point décrive une trajectoire aléatoire et qui soit également fluide (dérivable) et ceci au sein d'une surface délimite , en faisant quelque recherche sur internet les seuls mouvements aléatoires que je trouve sont des mouvement saccades (des segments de droites accolées ce qui donne une trajectoire globales dentés. pourriez vous me guider pour réaliser un algorithme qui réalise cette tache ?
merci
-----

[pm42]

Salut,

Une solution simple est de donner à ton point une position et une accélération initiale sous forme de vecteur. A chaque étape correspondant à un incrément dans le temps, tu fais varier cette accélération aléatoirement mais pas plus que de d'un certain pourcentage en norme par exemple.
Puis tu en déduis la nouvelle vitesse puis la nouvelle position.

Il y a d'autres techniques comme ici : https://math.stackexchange.com/quest...-random-curves

[Yosh2]

bonjour
pourriez vous me donner un lien vers des ressources pour m'apprendre a réaliser votre première solution , en effet étant plutôt novice en python partir d'un simple texte et l’implémenter en code est une chose très peu aise , en faisant quelque recherche j'ai cru comprendre que pour modéliser des vecteurs on utilisait numpy mais c'est tout.
En ce qui concerne le lien que vous m'avez propose , c'est en effet le type de trajectoire que je veux obtenir , néanmoins j'avoue ne pas avoir compris grand chose , mes connaissances limites en programmation ne me permettent pas de partir d'un simple pseudocode ( qui m' a l'air de faire usage de concepts mathématique sophistiques ) pour écrire moi même un code . Pourriez vous me guider davantage ?
merci a vous

[ArrowRise]

Tu peux partir de ça comme point de départ, tu auras des courbes "régulières" et obtenues aléatoirement mais certains petits trucs pourraient être modifiés

import numpy as np
import matplotlib.pyplot as plt
import random as rd
from scipy import integrate

acc_max = 1 
duree = 100

vect_acc = np.zeros((duree,2))
vect_vit = np.zeros((duree-1,2))
vect_pos = np.zeros((duree-2,2))

#generation d'une suite de vecteurs accélérations aléatoirement
for i in range(duree):
    for j in range(2):
        vect_acc[i,j] = rd.uniform(-1, 1)*acc_max
        
#intégration de ces accélérations par la méthodes des trapèzes pour en déduire la vitesse et la position
for j in range(2):        
    vect_vit[:,j] = integrate.cumtrapz(vect_acc[:,j])
    vect_pos[:,j] = integrate.cumtrapz(vect_vit[:,j])

plt.figure(figsize=[10,6])
plt.plot(vect_pos[:,0], vect_pos[:,1])
plt.grid()

[A voir en vidéo sur Futura]

[Yosh2]

bonsoir
merci a vous ArrowRise pour cet exemple de code, qui me permet d'avoir une idée a quoi ressemble ce genre d'algorithme, cependant en l’exécutant rien ne s'affiche , sachant que j'ai python 3.8 et que j'utilise pycharm (dernière version).
merci a vous

[ArrowRise]

Envoie un screen de l'erreur afficher sur le terminal mais tu dois installer matplotlib avant je pense que c'est ça le problème.

[pm42]

Envoie un screen de l'erreur afficher sur le terminal mais tu dois installer matplotlib avant je pense que c'est ça le problème.

C'est aussi qu'il manque le plt.show()

[ArrowRise]

plt.grid() est un plt.show() mais en ayant un affichage quadrillé

[pm42]

plt.grid() est un plt.show() mais en ayant un affichage quadrillé

Je veux bien une référence vers la doc qui indique cela et savoir pourquoi tous les exemples appliquent la convention habituelle : on trace tout, on peut même mettre le grid dès le début et on fait le show à la fin.

[Yosh2]

bonjour
en effet il manquait le plt.show(), merci a vous ce code réalise une grande partie de ce que je veux , reste maintenant a faire apparaitre le déplacement du point en temps réel, je vais essayer de chercher et bidouiller un peu par moi-même, et je reviens vers vous des que j'aurais d'autres questions.
merci a vous

[pm42]

reste maintenant a faire apparaitre le déplacement du point en temps réel

Cela peut se faire simplement avec plt.pause : on trouve plein d'exemples sur le Net.

[Yosh2]

bonjour
apres quelque recherche sur internet j'ai réussi a animer le mvt du point en apportant quelque modifications au code que vous m'avez propose
voici le nouveau code

import numpy as np                                               
import matplotlib.pyplot as plt                                  
from matplotlib.pylab import subplots, arange, xlim, ylim        
import random as rd                                              
from scipy import integrate                                      
from matplotlib.animation import FuncAnimation                   
                                                                 
fig, c = subplots()                                              
point, = c.plot(1,'o-')                                          
                                                                 
xlim(-1000, 1000)                                                
ylim(-1000, 1000)                                                
                                                                 
acc_max = 3                                                      
duree = 100                                                      
                                                                 
vect_acc = np.zeros((duree, 2))                                  
vect_vit = np.zeros((duree - 1, 2))                              
vect_pos = np.zeros((duree - 2, 2))                              
                                                                 
                                                                 
# generation d'une suite de vecteurs accélérations aléatoirement 
for i in range(duree):                                           
    for j in range(2):                                           
        vect_acc[i, j] = rd.uniform(-3, 3) * acc_max             
                                                                 
                                                                 
# intégration de ces accélérations par la méthodes des trapèzes p
for j in range(2):                                               
    vect_vit[:, j] = integrate.cumtrapz(vect_acc[:, j])          
    vect_pos[:, j] = integrate.cumtrapz(vect_vit[:, j])          
                                                                 
a = vect_pos[:, 0]                                               
b = vect_pos[:, 1]                                               
                                                                 
                                                                 
def af(i):                                                       
    point.set_data(a[i], b[i])                                   
                                                                 
                                                                 
anim = FuncAnimation(fig, af, arange(1000), interval=10)         
plt.show()                                                       
                                                                 
# plt.figure(figsize=[100, 600])                                 
# plt.plot(vect_pos[:, 0], vect_pos[:, 1])                       
# plt.show()

mais a présent je rencontre quelque fois une erreur IndexError: index 98 is out of bounds for axis 0 with size 98 , pourriez vous m'aidez a la résoudre , aussi est ce possible de faire apparaitre la trajectoire au fur et a mesure qu'elle est parcourut par le point ?
merci a vous