Discussion :

[cha266]

Bonjour a tous, je vien d'arriver sur ce forum, et je ne sait pas troop commen faire.

En fait, j'ai un probleme je dois realiser un algorithme qui aurai pour effet d'enlever les yeux rouges sur une image, photographie a partir d'une selection de ceux-ci préalablement faite.

Si quelqu'un peux m'aider dans l'elaboration de cet algo...

Merci d'avance

[cha266]

Pour etre plus precise je suis actuellement en train de develeppeper un outil de retouche d'image. Et là je fait un outil qui consiste à enlever les yeux rouges sur une photographie.

J'en suis à la réalisation de l'algorythme.

Ainsi je pense commencer par repertorier la couleur de mes pixel de ma selection. de garder ce qui sont rouge. Puis de les atténuer en les melangean evac une autre couleur. Seulement je nesuis pas sur de ma méthode.

Si quelqu'un pourrai me dire si je suis dans la bonne direction ou non cela me ferai plaisir.

Merci d'avance

[2Eurocents]

On peut rendre le traitement un peu plus complexe, mais plus efficace/naturel.

En retouche, pour retirer les yeux rouges, j'ai tendance à effectuer une désaturation de la sélection (en l'occurence, pour toi, transformer le RGB en HSL, annuler la composante S, et re-transformer en RGB).

Ainsi, je conserve les éclats lumineux (zone de reflet) qui peuvent être présents sur l'oeil.

[cha266]

merci pour ton conseil je vais y réfléchir, mais là pour mon algo je pars de ma selection, je recherche tous les pixels qui ont une part de rouge, puis sur ceux-ci je rajoute 70% de noir.

Seulement je ne sais pas si cela est possibe.

[2Eurocents]

Réfléchis bien à la désaturation de ta sélection ...

L'avantage, c'est que ça traite les yeux rouges, mais aussi les jaunes et les bleus

L'inconvénient, c'est que tu as besoin d'avoir une sélection précise ... sinon, tu vires aussi la couleur des yeux


Dans ton cas, comment envisage tu d'ajouter du noir ? Tes couleurs seront exprimées en RVB, donc sans composante noire, à part toutes les valeurs à zéro.

Pour les valeurs de R élevées, vas-tu supprimer du rouge ? Tu risques alors d'avoir des teintes en vert ou en bleu qui vont apparaître et altérer ton effet.

Une autre option serait, pour les valeurs élevées de R, de remplacer le pixel par un pixel dont chaque composante, R, V, B est cassée de 70% ( x 0.3 ). Ainsi, ta couleur se dilue dans le noir car tu baisse la luminosité de chaque composante. C'est cependant négliger la prépondérance de la perception des rouges et des verts par l'oeil, par rapport au bleu. Idéalement, le coefficient ne devrait pas être le même pour chaque composante.

Cette dernière remarque m'amène à revenir à la charge et à insister sur l'importance d'une conversion de RVB en TSL (Teinte/Saturation/Luminosité), suivie d'une altération de S ou L (mais d'expérience, S est plus naturelle au niveau du rendu) suivie d'un retour à l'espace RVB ...

[mathieu_t]

Cette dernière remarque m'amène à revenir à la charge et à insister sur l'importance d'une conversion de RVB en TSL (Teinte/Saturation/Luminosité), suivie d'une altération de S ou L (mais d'expérience, S est plus naturelle au niveau du rendu) suivie d'un retour à l'espace RVB ...

Tout à fait d'accord...

L'inconvénient, c'est que tu as besoin d'avoir une sélection précise ... sinon, tu vires aussi la couleur des yeux

Une solution serait de partir du centre de la pupille (sélectionné par l'utilisateur) et de faire une croissance par région (algo classique) en imposant de garder une forme elliptique (forme de la pupille)... C'est un peu plus complexe, mais c'est beaucoup plus agréable pour l'utilisateur !

[cha266]

Bien ton idee me parait tres interressante. Seulement j'ai aussi pensé à tout simplement baisser le contraste de 70% de mes differentes teintes de rouges.Et ensuite à la fin de mon algo, faire une autre fonction qui flouterai mes contours.

J'avoue que pour cet algo j'ai differentes possibilitées. La tienne est assez compliquée à mettre en place.

Sinon pour la selection, avant de faire appliquer cet outil anti-yeux rouges, l'utilisateur aura préalablement fait une selection de la pupille seul. Vu que la teinte rouge n'est que sur la pupille.De ce fait les autres pixel ayant du rouge ne seront pas altérés.

[cha266]

La structure de mon algo serait celle-ci. Bon je n'ai aucune syntaxe pour le moment, c'est juste la démarche:

Dans mon premier algo je parcours tous les pixels de ma selection pour en prendre la reference couleur. (c'est dans une boucle pour)
Je met ces reférences dans un tableau t[res].
Dans une seconde boucle, je parcour ce tableau t[res], et je ne garde que les pixel ayant une forte teinte de rouge (seulement je ne voi pas comment faire??)
Ensuite ces resulats se mettent dans ce tableau t[res] et ecrasent les données d'avant. A la fin de mon algo je retourne t[res].

Puis dans l'algo principal, avec l'appel de t[res], je diminue pour cahques pixels le contraste de 70%?? (est-ce possible??)

[cha266]

En reponse a "mathieu_t", j'aimerai avoir plus d'information sur ce que tu appel une selection de croissance par région. Quel effets cela a t-il??

C'est pour prendre que les pixels se raprochant d'une teinte précise?

[mathieu_t]

Dans une seconde boucle, je parcour ce tableau t[res], et je ne garde que les pixel ayant une forte teinte de rouge (seulement je ne voi pas comment faire??)

Il faut que tu crées une image en TLSpar exemple (sous google tu trouveras ton bonheur sur les conversions RGB->TLS) (HLS en anglais)

MessagePosté le: Mer Avr 13, 2005 9:31 Sujet du message:
En reponse a "mathieu_t", j'aimerai avoir plus d'information sur ce que tu appel une selection de croissance par région. Quel effets cela a t-il??

C'est pour prendre que les pixels se raprochant d'une teinte précise?

Oui en gros c'est ça : tu utilise la carte HLS (ou plutôt tu te concentres sur S) :

Code :

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

1
2
3
4
5
6
7
8
9
 
1 - tu pars d'un point initial
2 - tu regardes ses 4 voisins, et s'ils ont la même caractéristique, tu les ajoute à ta région (les pixels peuvent être rangés dans une liste ou une pile pour gagner de la mémoire)(en même temps  tu modifies leur saturation), sinon tu les laisses de côté
 
BOUCLE
3 -pour chaque nouveau pixel de ta région (ceux que tu viens d'ajouter), tu regardes les 4 voisins et tu regardes si chaque voisin appartient à la région, 
FIN BOUCLE
 
4 - ça s'arrête quand tu n'as plus de voisin qui correspond à la région

Pour dire si un pixel appartient à la région, tu regardes si son intensité en H, en L, en S est dans une même fourchette que le H/L/S de ton pixel initial...

Il faut quand même noter que l'inconvénient est ce qu'on appelle la "fuite" cad que qu'il se peut que ça ne s'arrête jms (si ton algo trouves toujours un pixel qui correspond aux valeurs HLS) ! Il faut donc bien règler la fourchette.

Enfin, , pour imposer une forme elliptique c un peu complexe, mais ça se fait:
un moyen simple est de faire en même tps que l'algo au dessus (dans la boucle) une liste des points qui constituent le contour de ta région actuelle,
et tu fais des calculs de compacité (voir google) qui te disent si ton contour est elliptique... En gros tu n'accepte les nouveaux pixels que si la forme générale (avec les nouveaux pixels) est elliptique...

Bon c un peu complexe tout ça mais je pense que c quand même applicable et ça vaut vraiment le coup parce que c beaucoup plus agréable pour l'utlisateur...

[cha266]

Ou là c'est compliqué tout ca mais enfait ce que tu me di c'est que cet algo detectera automatiquement les yeux???

Il ny a pas de risque que l'efet s'applique sur une autre partie de l'image?

[mathieu_t]

Euh quand même pas !
Il faut partir d'un point dans les yeux, sinon c la cata !

[cha266]

A ok, donc c'est l'utilisateur qui dira ou ce trouve ce point?

Mais moi ce que j'avais pensé, c'est que avant d'appliquer l'effet: l'utilisateur aura déja selectionner les pupille..
C'est plus simple non.

Mais j'avoue que j'ai du mal a realiser cet algo. Ce n'est pas ce que j'aime faire mais bon..

[cha266]

Si quelqu'un connait bien la syntaxe d'un algo pourrai t'il m'aider a l'ecrire??? Je l'est fini mais en francais avec des phrases, je ne sais pas comment l'appliquer

[cha266]

Je vous l'ecri::

Algo_Recherche
debut
pour li de 1 à n faire
#la je parcours ma liste de pixels
#Je prend la reference couleur(R,V,B)qui se trouve dans une cellule #PIXEL de chaques pixel
#c peu etre ca: lm.R=refR
lm.V=refV
lm.B=refB
i=i++
Fpour
Retourne (PIXEL)
Un autre algo:: qui appel mes reference couleur de chaques pixel::

Debut
Pour PIXEL de 1 àN faire
Si la reference R du pixel>90 alors
#je baisse le contraste de 70% sur ce pixel
FSi
Fpour
Fin


Ma syntaxe est completement fausse je le sais, mais je n'y arrive pas

[cha266]

hhhhhhhhhhhhhhhhhheeeeeeeeeeeeeee^llllpppppppp

[mathieu_t]

voici ce que tu veux en C++... Je l'ai fait pour RGB mais je te conseille de passer en HLS , c'est pas dur (et là le seul boulot que tu auras à faire c justement cette conversion ):

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
#include <list>
 
// ImageIn et ImageOut tableaux 1D de taille 3*WX*WY où WX = largeur et WY = Hauteur
// On aura précédemment recopié ImageIn dans ImageOut
// Point2D est une structure qui contient un champ x et un champ y (à toi de la créer)
// Pour accéder au pixel  (x,y) on fait 3*( x + y*WX) pour la 1ère composante
// 3*(x + y*WX) + 1 pour la deuxième
// 3*(x + y*WX) + 2 pour la troisième
void Algo_Recherche(list<Point2D> ListPoints, vector<int> ImageIn, vector<int> & ImageOut, int WX)
{
 
	std::list<Point2D>::iterator iter;
 
	for(int iter = ListPoints.begin(); iter != ListPoints.end(); ++iter)
	{
	 if(CouleurRouge(ImageIn[3*(*iter->x + *iter->y*WX)],ImageIn[3*(*iter->x + *iter->y*WX)+ 1],ImageIn[3*(*iter->x + *iter->y*WX) + 2])
// On ne prend que 30 % de la valeur initiale
		 ImageOut[3*(*iter->x + *iter->y*WX)] = 	0.3*ImageIn[3*(*iter->x + *iter->y*WX)];
	} 	
}
 
bool CouleurRouge(int R,int G, int B )
{
 int coef = 0.9; // dans ton cas
 
 return (R>coef*(G+B))? true:false;	
}

Pour le HLS, ImgOut doit être en HLS, et tu te concentres dans ta fonction CouleurRouge (que tu peux changer en Saturation par exemple) tu te concentres sur la 3ème Composante (cad le S).

A +

PS: j'espère que j'ai pas fait une erreur de code, mais c'est pas inévitable vu que je suis un peu crevé

[cha266]

Je te remercie Matthieu ...
Parce que j'ai vraiment du mal avec les algos
Je vais essayer de comprendre comment il fonctionne
Puis apres comme tu me la dis essayer de le mettre pour HLS. Mais pourquoi?? C'est parce-que en RVB cela ne rendrai pas bien?

[cha266]

Il y a quelque chose que je ne comprend pas a la fin de ton code:::

On ne prend que 30 % de la valeur initiale
ImageOut[3*(*iter->x + *iter->y*WX)] = 0.3*ImageIn[3*(*iter->x + *iter->y*WX)];
}
}

bool CouleurRouge(int R,int G, int B )
{
int coef = 0.9; // dans ton cas

return (R>coef*(G+B))? true:false;
}


Enfait je ne sait pas d'ou vienne les 30%, c'est pour les contrastes?? Puis aussi parce que apres tu mets le 90? (cela correspond au nombre à partir du quel je veux appliquer la baisse de contraste?

[mathieu_t]

Bah je prends 30% parce que tu m'as dit que tu voulais basser de 70% le rouge (non ?)... Donc enlever 70% revient à prendre que 30%...

Ensuite le 90% dit en gros que R est à 90% supérieur au vert et au bleu (en gros).... Bon je t'ai mis 90% parce que c'est ce que tu voulais, mais moi j'ai plus l'habitude de mettre 60%... Sinon tu as que du rouge pur...

Enfin pourquoi utiliser HLS, c'est tout simplement parce que retirer 70% de rouge comme ça, en général ça donne des résultats pas beaux ! Mais essaye déjà avec ça, et passe en HLS si tu voies que ça ne donne pas ce que tu souhaites...

A+.