Discussion :

[pat-trix]

Bonjours à tous!

Voici ma question:
J'ai créer une animation de voile dans laquelle la direction de vent est donnée par un 'trait' se finissant par une flèche. Pour donner un peu de réalisme à l'animation, j'aimerais créer un vent qui pourrait changer légèrement de direction (on va dire de + 8° et de - 8°) et de force (trait augmente de +/- 12 pixels). J'ai pensé à un thread et a Math.random, mais j'aurais besoin d'aide pour quelque chose de concret.

NB: enfait il faut que je redefinisse les coordonnées de l'extrêmité du "trait" (lx,ly), les coordonées du début du "trait" ne changeant pas...!

Merci d'avance,

Pat-trix

[®om]

Pour avoir une valeur aléatoire entre 0 et 1 (suivant une loi uniforme), tu fais Math.random();. Pour l'avoir entre -8 et +8 (en dégres), et bien tu multiplies par 16 et tu enlèves 8.

Si tu veux plus de réalisme (petit a parte mathématique):
Pour que ça soit plus "réalise", il vaut mieux utiliser une loi normale plutôt qu'une loi uniforme (plus de chances d'être dans la moyenne). Pour cela, tu te rappelles du théorème centrale limite, qui te dit que la somme d'évènements indépendants et identiquements distribués tend vers une loi normale lorsque le nombre d'évènements tend vers l'infini (l'infini pouvant être petit -ça marche pour des n pas si grand que ça-).
Donc supponsons qu'on veuille obtenir une distribution de loi normale de moyenne 0 et de variance... disons 15 (pour se trouver souvent entre -8 et +8 : en réalité, la probabilité d'être entre -8 et +8 est de 96,06% avec cette variance).
Après quelques calculs (à vérifier d'ailleurs), avec n = 10 (ça suffit pr ce que tu veux faire), en gros tu fais:

Code :

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

1
2
3
4
5
6
final int N = 10;
double somme = 0;
// on fait la somme de 10 v.a. uniformes iid sur [0;1]
for(int i = 0; i < N; i++)
    somme += Math.random();
double resultat = 14 * somme - 7 * N;

Et voilà, "resultat" suit une loi normale qui devrait te convenir...


Bon ça c'était pour l'a parte, ensuite, il faut que tu fasse une rotation de ton vecteur de la valeur cet angle... Pour cela, il te suffit de multiplier à gauche ton vecteur par la matrice:

Code :

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

1
2
cos(a)  -sin(a)
sin(a)  cos(a)

autrement dit, pour ton vecteur (x,y):
x' = x cos(a) - y sin(a)
y' = x sin(a) + y cos(a)
Tu ajoutes ce vecteur (x',y') au point d'origine du vecteur et tu as le point "destination" du vecteur...

[®om]

Ah et j'oubliais, une fois que tu as obtenu une nouvelle directection aléatoire, par interpolation, fait tourner ta flèche en animation, car sinon ça fera un changement brut de direction...

[pat-trix]

Merci pour ta réponse Rom!

Enfait, pour commencer je vais essayer de faire varier mon vecteur avec Math.random *16 -8, pour voir si le concept marche. Pourtant, en utilisant la matrice je n'obtiens aucun résultat, voici le code écrit:

Code :

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

1
2
3
4
5
6
7
 
                int resultat //en radians
                resultat=(int)((((Math.random()*16)-8))*Math.PI/180);
 
                 //Nouveau vecteur (lx et ly sont les extremités du vecteur)
                 lx=(int)(lx*Math.cos(resultat)-ly*Math.sin(resultat));
                 ly=(int)(lx*Math.sin(resultat)+ly*Math.cos(resultat));

Le vecteur ne bouge pas du tout; Sinon, tu as raison, je dvrais utiliser une animation, mais je ne sais vraiment pas comment faire ?!

Merci d'avance !
PAt-trix

[®om]

Merci pour ta réponse Rom!

Enfait, pour commencer je vais essayer de faire varier mon vecteur avec Math.random *16 -8, pour voir si le concept marche. Pourtant, en utilisant la matrice je n'obtiens aucun résultat, voici le code écrit:

Code :

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

1
2
3
4
5
6
7
 
                int resultat //en radians
                resultat=(int)((((Math.random()*16)-8))*Math.PI/180);
 
                 //Nouveau vecteur (lx et ly sont les extremités du vecteur)
                 lx=(int)(lx*Math.cos(resultat)-ly*Math.sin(resultat));
                 ly=(int)(lx*Math.sin(resultat)+ly*Math.cos(resultat));

Le vecteur ne bouge pas du tout; Sinon, tu as raison, je dvrais utiliser une animation, mais je ne sais vraiment pas comment faire ?!

Merci d'avance !
PAt-trix

C'est normal :

Code :

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

resultat=(int)((((Math.random()*16)-8))*Math.PI/180);

Le résultat en double est entre 0 et 1, si tu le castes en int, ça fait 0...

Mais bon, c'est de ma faute, sur mon exemple, j'avais mit "int resultat", j'ai corrigé, mais il faut bien sûr:

Code :

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

1
2
double degrees = Math.random() * 16 - 8;
double resultat = Math.toRadians(degrees);

[sinok]

Pour l'animation c'est simple tu vas graduellement changer la direction de ton vent entre sa direction d'origine et celle de destintation :

• tu calcule l'angle le plus court pour atteindre ta nouvelle position
• puis tu vas ajouter/retrancher (tout dépend de si l'angle de rotation est inférieur ou supérieur à Pi) un petit montant sur l'angle actuel toutes les x millisecondes (genre du Pi/64 ou plus si tu as besoin de plus de fluidité).
• et ce tant que tu n'as pas rejoint un certain delta autour de la direction voulue

[pat-trix]

Désolé, je n'ai pas été futé pour le int Math.random...!

Alors maintenant, en effet le vecteur se déplace de manière aléatoire, mais au bout de quelques seconde, et de manière progressive, lx et ly rejoignent (0,0) et mon vecteur est un point...?

Merci en ce qui concerne le côté animation, je pense pouvoir réaliser cela...

Merci encore,

PAt-trix

[®om]

Alors maintenant, en effet le vecteur se déplace de manière aléatoire, mais au bout de quelques seconde, et de manière progressive, lx et ly rejoignent (0,0) et mon vecteur est un point...?

Cette matrice de rotation doit marcher pour les vecteurs de norme 1. Donc multiplie à chaque fois x' et y' par la norme du vecteur (Math.sqrt(x*x+y*y)).

EDIT: Euh, non, normalement la norme reste bonne...

[pat-trix]

Héy!

Bah ça marche toujours pas, le "vecteur" vent diminue toujours jusqu'à devenir un point.
Voici le code, 'lx' et 'ly' étant les extremités de la 'g2d.drawline' et 'resultat' l'angle changeant aléatoirement

Code :

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

1
2
3
 
   lx=(int)(lx*Math.cos(resultat)-ly*Math.sin(resultat));
   ly=(int)(lx*Math.sin(resultat)+ly*Math.cos(resultat));

Je ne comprend pas pourquoi cela ne marche pas...!

Merci d'avance,

Patrick

[®om]

Héy!

Bah ça marche toujours pas, le "vecteur" vent diminue toujours jusqu'à devenir un point.
Voici le code, 'lx' et 'ly' étant les extremités de la 'g2d.drawline' et 'resultat' l'angle changeant aléatoirement

Code :

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

1
2
3
 
   lx=(int)(lx*Math.cos(resultat)-ly*Math.sin(resultat));
   ly=(int)(lx*Math.sin(resultat)+ly*Math.cos(resultat));

Je ne comprend pas pourquoi cela ne marche pas...!

Merci d'avance,

Patrick

Mais pourquoi tu castes en int?
C'est ton int qui arrondi par défaut, et donc diminue le résultat...
Tes coordonnées doivent être en double...

[bouye]

Pour l'animation c'est simple tu vas graduellement changer la direction de ton vent entre sa direction d'origine et celle de destintation :

Et son intensite egalement.

[®om]

Tu as réussi ?

[®om]

Si tu veux plus de réalisme (petit a parte mathématique):
Pour que ça soit plus "réalise", il vaut mieux utiliser une loi normale plutôt qu'une loi uniforme (plus de chances d'être dans la moyenne). Pour cela, tu te rappelles du théorème centrale limite, qui te dit que la somme d'évènements indépendants et identiquements distribués tend vers une loi normale lorsque le nombre d'évènements tend vers l'infini (l'infini pouvant être petit -ça marche pour des n pas si grand que ça-).
Donc supponsons qu'on veuille obtenir une distribution de loi normale de moyenne 0 et de variance... disons 15 (pour se trouver souvent entre -8 et +8 : en réalité, la probabilité d'être entre -8 et +8 est de 96,06% avec cette variance).
Après quelques calculs (à vérifier d'ailleurs), avec n = 10 (ça suffit pr ce que tu veux faire), en gros tu fais:

Code :

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

1
2
3
4
5
6
final int N = 10;
double somme = 0;
// on fait la somme de 10 v.a. uniformes iid sur [0;1]
for(int i = 0; i < N; i++)
    somme += Math.random();
double resultat = 14 * somme - 7 * N;

Et voilà, "resultat" suit une loi normale qui devrait te convenir...

Oulà, je me suis bien galéré, je viens d'aller voir la classe Random pour faire autre chose, et j'ai vu qu'il y avait un nextGaussian()... Voilà, donc il suffit d'appeler nextGaussian()