------------------------------------------------------------
                                |  Le Blur Radial ou comment on fait du Bliur en Rond ! :) |
                                ------------------------------------------------------------

1. De quoi on a besoin :
------------------------

- un pc, une image, un compilo :), et pis des libs si vous voulez !!! :)

petits rappels :
----------------

(tout les bouts de code, seront en C)

Normalisation de vecteurs :
---------------------------

void Normalize( float &x, float &y )
{ 
  float lenght;

  lenght = sqrt( x*x + y*y );

  x /= lenght;
  y /= lenght;
}

Calcul d'un vecteur :
---------------------

On veut calculer le vecteur entre le point A(x,y) et B(x,y) et mettre le resultat dan V(x,y) :

Vx = Ax - Bx;
Vy = Ay - By;

et voila, V(x,y) contient le vecteur entre A(x,y) et B(x,y) !!!

voila pour les rappels....

2. Deroulement de l'algo :

on va imaginer 1 point qui se balade dans l'ecran et on dira que c'est notre centre du blur, a partir de ce point,
on va tracer 2 perpendiculaires qui se croisent sur ce point, donc on a notre ecran diviser en 4 partie, non ?????

ben voila, maintenant il faut calculer le blur pour chaque quart d'ecran qu'on a

petit bout de code qui calcule le radial blur pour le quart haut gauche :

MonRadialBlur( Image *bmp, int centre_blur_x, int centre_blur_y, int intensity )
{
  int x,y; // pour les boucles
  float vx,vy; // notre vecteur qu'on va traffiquer
  int px,py // coord du point courant apres calcul....
  int p1,p2; // nos deux pixels a additionner 
  int pixel_final; // ben le pixel final ! :))))))

  // aller, on commence a boucler en partant du centre_blur ( ki bouge tout le temps hein !!! :) ) :
  for ( y=centre_blur_y; y!=0; y-- )
  {
    for ( x=centre_blur_y; x!=0; x-- )
    { 
      // d'abord on calcule le vecteur par rapport au point courant : 
      vx = (float)(centre_blur_x - x);
      vy = (float)(centre_blur_y - y);

      // Apres, on le normalize pour ramener le vecteur a 1
      Normalize( vx, vy );

      // ensuite on lui donne une puissance ( entre 1 et 5 c'est pas mal... cf. tut Allergy =) )
      vx *= intensity;
      vy *= intensity;

      // on l'ajoute au pixel courant :
      px = vx + x;
      py = vy + y;

      // et maintenant on peut calculer nos 2 points...
      p1 = bmp[ x+ y * largeur_ecran];
      p2 = bmp[px+py * largeur_ecran]; // notre point qu'on a calculer ! :)

      // et on a plus qu'a le reposer sur l'ecran.... Attention pas de double buffer, sinon ca marche pô ! :)
      pixel_final = (p1 + p2) / 2;
      bmp[ x + y * largeur_ecran] = pixel_final;
   
      // et voila, maintenant il faut faire ca pour les 3 autres quarts ! et ouai !
    }
  }
}

et voila !!!!
bon, je vous emmerde pas avec le fait de verifiez si pixel_final est compris entre 0 et 255 et tout le bordel, hein ! :)

3. Optimisations
----------------

Comme vous l'avez vu, on normalize le vecteur.... donc, a chaque boucle, on fait un sqrt() pour chaque
pixel, et ca, pas bien ( sauf sur un Pentium IV a 1,4 Ghz ca doit tourner pas mal ! :) )
A mon avis, il faudrait precalculer un table de sqrt... mais bon, je vous laisse vous en occuper... :)

4. Les derniers mots
--------------------

Voila, voila, la 1ere doc de tonton steve est finie !!! :)

si vous avez aimer ou pas aimer:

Stv@goyave.com

je voudrais remercier tout ceux ki m'on aider a faire tourner ce #@!§# de radial blur :

- U2
- Alrj
- Still
- Impulse

et voila ! :)

a+ pour une autre doc.

				Stv / Syn[Rj]