Discussion :

[cyber_N]

HELLO LE MONDE !! 8)

Est ce que quelqu'un saurait traiter une image (modifier sa zone de données donc !!) de telle facon qu'elle produise un zoom (ce qui s'appel aussi un flou radial avec photoshop; dans flou radial, il y a "rotation" et "zoom").

Cet effet produit donc un "étirement" des pixels qui s'étirent de moins en moins à mesure qu'on se rapproche du milieu (centre que l'on a défini)
(C'est donc "une sorte" de flou gaussien mais spéciale).

MERCI.

[JHelp]

Peux-tu nous mettre un exemple sur deux petites images, genre avant/apres
Comme je connais pas photoshop je comprends pas bien ce que tu veux daire

[SKZ81]

Il faut utiliser, en plus de l'image d'origine, une structure de donnée qui peut acceuillir un nombre quelconque de couples {couleur, coefficient} pour chaque point.
Chaque point est projeté, dans une direction radiale, selon une longueur qui dépend de la distance du point au centre (à priori proportionelle, mais ça peut dépendre). Sur chaque point où passe, il "dépose" un peu de sa couleur, de moins en moins au fur et à mesure où il s'éloigne. Ca c'est la partie "radiale".
Ensuite, il faut faire, pour chaque point de l'image, faire la moyenne pondéré [des couleurs], entre le point de départ affecté du coef 1, et de toutes les "traces" laissée sur ce point, pondéré par le coefficient sus-cité. (Ca c'est le flou).

Formalisons un peu tout ça... (les // indiquent les commentaires)

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
 
// tracé "radial"
POUR chaque point (p) DO
  point p_courant = p; 
  couleur coul = get_couleur(p); // coul est la couleur du point que l'on traite.
 
  dist = distance(centre, p); // centre est le centre du flou, donné par l'utilisateur
  dist_flou = dist * coef; // coef est le paramètre utilisateur [distance propelle]
  // dist_flou = f(dist, coef); // autre possibilitée, f à determiner
 
  DO
    dist_p_courant = distance(p, p_courant);
 
    p_courant = next(); // fonction next détaillée en explication, plus bas
    put_trace(p_courant, coul, g(dist_p_courant, dist_flou) ); // idem pour g()
 
  WHILE(dist_p_courant < dist_flou) 
END
 
// flou
POUR chaque point(p) DO
  couleur c = get_couleur(p);
  reel total_poids = 0;
 
  POUR chaque trace(t) de p DO
    c = c + t.couleur * t.coef; // attention aux débordement dans un vrai language !!
    total_poids = total_poids + t.coef;
  END
 
  coul = coul / total_poids; (moyenne)
  set_couleur(p, coul); // on remplace la couleur. On peut faire le set sur une autre image...
END

Voilà, je crois que l'algo, bien que générique et assez complet et fonctionnel. Ha si, quand même, il manque le clipping (tests de débordement de l'image, dans la partie "radiale").

Note : il est bien évident que mon algo ne considère qu'une seule composante. Ce n'est pas un soucis, il suffit de répéter l'opération pour chaque composante RGB. (eventuellement, coder un opérateur en C++, mais tu n'as pas précisé le language d'implémentation...)

Fonction g() : pour une décroissance linéaire,
g(dist_p_courant, dist_flou) = dist_p_courant/dist_flou
Mais toute autre fonction décroissante, égale à 1 si dist_p_courant == 0 et égale à zéro pour dist_p_courant == dist_flou, exponentielle par exemple, est possible.

Autre note : avant que tu pose la question, on ne peut pas faire autrement que d'attendre d'avoir toutes les traces qui passent sur un point avant de faire la moyenne. Au mieux, on peut (mais alors OBLIGATOIREMENT dans une deuxième image) additionner au fur et à mesure les couleurs*coef, et en parallèle les coefs, sur le coef total associé au point.

Pour next(), c'est l'algo de Bresenham... ici en assembleur IBM 1401, pour le fun ... Ou là, wikipedia c'est bien pour comprendre (voire pomper, c'est domaine public!).
Si tu veux mieux :

Ceci dis, on peut faire une remarque : il n'est pas necessaire de considerer d'autres points que ceux qui se situent une ligne donnée, entre un point du bord de l'image et le centre.
On peut donc calculer cette ligne une bonne fois pour toute avec Brensenham, en stockant les points dans une liste [doublement?] chainée (plutôt que de les afficher). On part ensuite du centre pour aller vers l'extrémité. La fonction next() utiliserait, dans ce cas cette liste.
Tu remarquera que je n'ai pas indiqué d'ensemble "de définition" pour p dans mes
"POUR chaque point(p) DO".

Pour conclure, je ne suis pas sûr que cet algo donne des resultats aussi net que Photoshop. Il faut peut-être s'interesser, plutôt qu'à une projection, à une rétroprojection (pour chaque point, on calcule non pas les traces laissées SUR les autres points mais PAR les autres points). C'est pour cela que j'ai laissé un "doublement chainée" trainer dans les explications.

Et enfin, ce n'est valable que pour une transformation d'une image fixe vers une autre image fixe. Si tu veux (eventuellement) faire une animation temps réél, il y a des astuces à appliquer.

Mais j'ai déjà bcp réfléchi pour toi !!

[cyber_N]

je souhaiterais mettre des images pour illustrer ce zoom mais je ne sais pas comment procéder:
mon image est sous le z:\
je ferais donc ceci ?? : (avec des [] autour de img et /img)
img http://z:/av_img.bmp/ /img

merci.

[Laurent Gomila]

Il faut que ton image soit online (le forum ne peut pas héberger les images postées, sinon il saturerait vite ).

Si tu n'as pas d'espace perso : www.imageshack.us

[SKZ81]

Eureka !!!

J'ai un peu tout faux sur ce que j'ai dis dans le post précédent : en fait si prends comme ensemble de definission du POUR_TOUT (p) l'image, tu te heurte au calcul du rayon et donc à son imprécision.
Si tu employes la méthode des points du bord, les rayons sont calculés préciséments et une fois pour toute (l'algo devient :

Code :

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

1
2
3
4
5
6
7
8
 
POUR_TOUT point(p) du bord de l'image
  r = calculer_rayon_bresenham( p, centre );
  POUR_TOUT point(p) de r
    // partie radiale
    // flou
  FIN_POUR
FIN_POUR

Là le soucis est que les rayons se superposant aux abords du centre, tu va traiter certain points plusieurs fois. Donc il faut :
- Soit mettre un booléen sur chaque point. S'il a été traité, il ne le sera plus.
- Soit fusionner les rayons en un arbre, que tu parcours avec une fonction récursive pour le backtrack.

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
 
FONCTION partie_radiale(point p) 
...
    SI ( next_count() == 0) ALORS FIN_partie_radiale; 
    // pas de succésseurs ---> return, fin de sous-programme
 
    SI ( next_count() == 1)
    ALORS p = next();
    SINON FAIRE
      s = set_next();
      POUR_TOUT point(q) de s
        partie_radiale(q);   // on rappelle la même fonction (récursive)
      FIN_POUR_TOUT
    FIN_FAIRE
...
FIN_partie_radiale;

[mamelouk]

je remonte sans honte ce vieux post pour savoir s'il y a un algo de référence pour implémenter le flou radial.

[pseudocode]

Il y a des methodes exactes (math) : passage en polaire avec flou horizontal

Il y a des méthodes rapides (démomakers) : diffusion des intensités en partant du centre.

[mamelouk]

ok je suis parti sur la méthode exacte. j'ai affiché l'image transformée en polaire pour le fun, avec le 0,0 au milieu de l'image. par contre je comprends pas ce que tu veut dire par appliquer un flou horizontal. l'appliquer sur quoi ? l'image polarisée? puis dépolariser l'image ensuite?

[pseudocode]

par contre je comprends pas ce que tu veut dire par appliquer un flou horizontal. l'appliquer sur quoi ? l'image polarisée? puis dépolariser l'image ensuite?

Oui, c'est cela. Tu peux meme faire une diffusion horizontale plutot qu'un flou horizontal pour avoir un effet de profondeur.