http://www.saphir-control.fr/

Scilab : l'environnement graphique (2/2)
Animation

Contexte graphique

Driver Rec et driver X11

--> driver("X11")

Mode pixmap

Mode Xor

Exemple

Modèle

Simulation

function [b,c,d,e]=initialise(n)
rand("normal") //loi normale utilisee pour rand
b=rand(n,1);d=rand(n,1); //vitesses intiales
c=3*[1:n]';e=rand(n,1); //positions initiales
endfunction

1. On est à t=0 et on calcule l'instant du prochain choc t_c. On a vu que le calcul de t_c nécessite la résolution de plusieurs équations du second degré, ce qui peut être vectorisé dans Scilab comme suit :

   
   function [tc,k]=prochain_choc(b,c,d,e)
   A=(P*b).^2+(P*d).^2;
   B=(P*b).*(P*c)+(P*d).*(P*e);
   C=(P*c).^2+(P*e).^2-4*r2;
   rac=[(-b-sqrt(b.^2-2*g*c))/g;
       -(10+e)./d;(10-e)./d;
       (-B-sqrt(B.^2-A.*C))./A]; //calcul des instants de choc
   rac(find(imag(rac)<>0))=%inf;//supprimer racines complexes
   rac=real(rac);
   rac(find(rac<=10*%eps))=%inf;//supprimer tc<0
   [tc,k]=min(rac);  //calcul de tc (premier choc)
   endfunction
   
   

   La matrice P contient un 1 et un -1 sur chaque ligne de telle façon que les composantes P*b soient b_i-b_j pour tout i différent de j, idem pour c, d et e. tc est le temps correspondant au prochain choc et k indique quel choc sera produit à tc (quelle balle contre quelle parois ou contre quelle autre balle).
2. On calcule et mémorise les trajectoires des balles de 0 à t_c. Le calcul de la trajectoire est facile car la solution explicite est disponible ; il suffit de discrétiser le temps :

   
   function [x,y]=trajectoire(b,c,d,e,t)
   // calcul de la trajectoire (x,y)
   // etant donne un vecteur de temps t
   y=.5*g*ones(n,1)*t.^2+b*t+c*ones(t); 
   x=d*t+e*ones(t);         
   endfunction
   
   

3. On affiche successivement les positions des balles. On peut aussi bien utiliser xfpolys que xfarcs pour dessiner les balles. On dessine toutes les balles avec une seule commande graphique :

   
   function TT=anim(x,y,t,TT)
   I=size(t,"*");
   for i=1:I-1 
     xset("wwpc") //effacer 
     xfpolys((x(:,i)*s+cerclex)',(y(:,i)*s+cercley)',[1:n])
     //    TT=TT+DT;realtime(TT);  //pour mode temps reel
     xset("wshow")           //dessiner
   end  
   i=I;  //le cas i=I traiter a part pour le temps reel
   xset("wwpc")   //effacer
   xfpolys((x(:,i)*s+cerclex)',(y(:,i)*s+cercley)',[1:n])
   //  deux lignes suivantes pour mode temps reel
   //  if I>1 then TT=TT+t($)-t($-1);else TT=TT+t($);end
   //  realtime(TT);  
   xset("wshow")   //dessiner la derniere position (choc)
   endfunction
   
   

   La variable TT sera utilisée pour gérer l'animation temps-réel que nous verrons un peu plus tard. La gestion temps-réel est aussi la raison pour laquelle le cas i=I a été traité à part.
4. On fait un changement de coordonnées pour remettre le temps courant (t_c) à zéro. Pour cela il suffit de remplacer les c_i par y_i(t_c)=1/2gt_c²+b_it_c+c_i, les e_i par x_i(t_c)=d_it_c+e_i et les b_i par g*t_c+b_i.

   
   function [b,c,d,e]=nouv_coor(b,c,d,e,tc)
   // changement de coordonnees pour remettre le temps a 0
   c=.5*g*ones(n,1)*tc.^2+b*tc+c;
   e=d*tc+e;
   b=g*tc*ones(n,1)+b;
   endfunction
   
   

5. On modifie les vitesses en fonction de type du choc. Tout est vectorisé dans ce cas pour éviter des boucles.

   
   function [b,c,d,e]=apres_choc(b,c,d,e)
   // gestion du choc
   if k<n+1 then  //choc avec le sol
     b(k)=abs(b(k));
   elseif k<2*n+1 then //choc avec la paroi gauche
     d(k-n)=abs(d(k-n));
   elseif k<3*n+1 //choc avec la paroi droite
     d(k-2*n)=-abs(d(k-2*n));
   else   // balle contre balle
     m=k-3*n;
     mm=find(P(m,:)<>0);m1=mm(1);m2=mm(2); //balles m1 et m2
     del=(c(m1)-c(m2))/(e(m2)-e(m1));
     alpha=-(b(m1)-d(m1)/del-b(m2)+d(m2)/del)/(1+(1/del)^2);
     b(m1)=b(m1)+alpha;    b(m2)=b(m2)-alpha;
     d(m1)=d(m1)-alpha/del;    d(m2)=d(m2)+alpha/del;
   end
   endfunction
   
   

6. On recommence l'étape 1.

Script Scilab

n=5;  // nombre de balles
g=-9.8; 
r=1.3;r2=r^2; //rayon des balles
// dessins des balles -> cercles approx par polylines 
s=[0:.2:2*%pi];
cerclex=ones(n,1)*r*cos(s);
cercley=ones(n,1)*r*sin(s);
s=ones(s);
//Matrice P telle que [P*x] = x_i - x_j
P=[];
for i=n-1:-1:1
  P=[P;[zeros(i,n-1-i),ones(i,1),-eye(i,i)]];
end
// contexte graphique pour l'animation
driver X11;xset("pixmap",1);xset("wpdim",300,430);
xsetech(wrect=[0,0,1,1],arect=[0,0,0,0]) 
// frameflag=4 correspond a isoview -> balles rondes
plot2d([-10-r,-10-r,10+r,10+r],[20,-r,-r,20],frameflag=4)
xset("colormap",rand(n,3,"uniform")) //couleur des balles 
xset("wwpc") // efface le contenu
//
TT=0;DT=.04; // discretisation en temps
//realtimeinit(1);realtime(TT); // pour mode temps reel

[b,c,d,e]=initialise(n);

while %t   //boucle infinie
  [tc,k]=prochain_choc(b,c,d,e);
  t=DT:DT:tc;t=[t,tc]; //disrectisation du temps
  [x,y]=trajectoire(b,c,d,e,t);
  TT=anim(x,y,t,TT);
  [b,c,d,e]=nouv_coor(b,c,d,e,tc);
  [b,c,d,e]=apres_choc(b,c,d,e);
end

Temps-réel

SCI/routines/scicos/realtime.c

#include "stack-c.h"

int intsrealtimeinit(fname)
   char *fname;
{
 int m1,n1,l1;
 double zer=0.0;
 CheckRhs(1,1);
 CheckLhs(1,1);
 /*  checking variable scale */
 GetRhsVar(1,"d",&m1,&n1,&l1);
 CheckScalar(1,m1,n1);
 /* cross variable size checking */
 C2F(realtimeinit)(&zer,stk(l1));
 LhsVar(1)=0;
 return 0;
}

int intsrealtime(fname)
   char *fname;
{
 int m1,n1,l1;
 CheckRhs(1,1);
 CheckLhs(1,1);
 /*  checking variable t */
 GetRhsVar(1,"d",&m1,&n1,&l1);
 CheckScalar(1,m1,n1);
 /* cross variable size checking */
 C2F(realtime)(stk(l1));
 LhsVar(1)=0;
 return 0;
}

-->table =["realtimeinit","intsrealtimeinit";
-->        "realtime","intsrealtime"];

-->ilib_build("libtempsreel",table,"tempsreel.o",[])

-->exec loader.sce
 

This document was translated from L^AT_EX by H^EV^EA.

This document was translated from L^AT_EX by H^EV^EAÿÿÿ