Discussion :

[amiine]

Salut a tous ! j'espère que vous allez tous trés bien.
j'ai à réaliser un programme qui extrait les classes de couleurs d'une image RGB, à condition que ces classes soient les plus représentatives possibles,
voilà ! toute aide de votre part me serait bénéfique et merci d'avance !

[parp1]

tu peux nous en dire plus car ce sujet est deja implémenté dans plusieurs languages... Quel language? Python -- utilise PIL
VB -- va voir la faq
C# Telecharges graphic filter for Dummies.du moins les sources.

Ca sert a rien de réinventer l'eau chaude...

Voila

[amiine]

merci infiniment pour ton message parp1, mais justement je cherche une orientation, pour ne pas réinventer l'eau chaude, j'utilise builder c++, mais je peux utiliser C# si c'est plus interessant.

[PRomu@ld]

un programme qui extrait les classes de couleurs d'une image RGB,

C'est une segmentation que tu veux faire ?

[parp1]

Dis moi, c'est un challenge que tu te donnes?

Parce que tout ce que je peux te dire c'est que dans un fichier raw les composantes sont stockées du type

[r,g,b,r,g,b,r,g,b,r,g,b,r,g,b].... XxY pixels (pas sur).

Le truc que tu peux faire c'est une vulgaire boucle que remplit trois tableau.

Code :

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

1
2
3
4
5
6
7
8
image[nbpixels] = dataImg
 
for i in range (nbpixel):
 
      rouge[i]=image[i]
      vert[i]=image[i+1]
      bleu[i]=image[i+2]
next i

tu a normalement tes trois tableaux avec tes trois composante.

Voila.... Cordialement.

[parp1]

C'est une segmentation que tu veux faire ?

Je pense qu'il veut séparer les trois composantes de couleurs. Mais il nous en dit trop peux.

[amiine]

Salut à tous ! et merci beaucoups pour les efforts que vous faites pour
m'aider, cette fois-ci je vais etre plus clair :
le projet que j'ai à réaliser s'intitule "indexation et recherche des images", l'indexation d'images consiste à relever de celle-ci les couleurs les plus représentatives, et leurs quantités respéctives, c-à-d leurs intervalles - on se préoccupe pas de la valeur de chaque pixel- par exemple une image qui est composée de 100000 pixels, chacun différents des autres, mais qu'en la regardant avec les yeux, on voit qu'elle se compose de 2 couleurs pricipales, jaune et noir par exemple, alors le problème c'est de faire comprendre ça à la machine pourque dans la phase de recherche on evite de la comparer avec les images requetes qui contiennent principalement d'autres couleurs,
ce que j'ai fait jusqu'à maintenant c'est de réaliser les histogrammes des 3 composants (RGB) ensuite je cherche à extraire les pics deces histogrammes...etc j'éspère que c'est plus claire maintenant, n'importe quelle aide, doc, orientation
est trés appreciée, merci !
illustration :

[takoha]

Salut,

Pour mon projet de l année derniere, il fallait faire une reduction des couleurs d une image et y appliquer certain filtres.

J avais fait une reduction mediane des couleurs.

En gros tu faits 3 histogrammes et tu construit un arbre binaire recusivement en coupant l histogramme en 2 moitié egale en poids (au niveau du barycentre quoi).

Au final tu as les (2^hauteur de l arbre)^3 couleurs les plus representatives.

Idealement il ne faudrait pas travailler sur les 3 histogrammes separement mais cela consommerai bcp trop de ressource (65Mo environ rien que pour stocker l histo en 3d)

Pour assigner (comparer ds tons cas) les couleurs je calculer la difference minimale de la norme entre 2 points ds l espace 3d des couleurs.

Plus simple tu peux aussi essayer de remplir une table des couleur de valeur fixée uniformement repartit pour chaque image et ensuite comparer ces tables.
Si tu doit comparer une serie d image avec une forte dominance vers une couleurs particuliere evidement c'est bcp moins bon.

Encore plus simple, tu peux calculer les n couleur les plus representées. A l inverse de l algo precedent c'est plutot mauvais si tu as des couleurs sur un large spectre.



@+
Avi

[amiine]

Merci beaucoup mon ami ; j'essayerais de suivre tes conseils et j'éspere bien avancer avec cela ! bonne nuit

[pseudocode]

d'accord avec parp1. Ce que tu veux faire c'est de la segmentation, mais sur les couleurs.

Le plus simple c'est de prendre cheaque pixel de ton image et de convertir sa valeur RGB en valeur HSV. Seule la composante H (Hue) va nous interesser (enfin presque, voir en bas)

Tu créés un tableau des intervalles de valeurs Hue que tu estimes pertinents, par exemple:

HueArray[0] = nmbre de pixels avec un Hue entre 40 et 60 (orange)
HueArray[1] = nmbre de pixels avec un Hue entre 60 et 70 (jaune)
...
HueArray[N-1] = nmbre de pixels avec un Hue entre 300 et 350 (violet)
HueArray[N] = nmbre de pixels avec un Hue entre 350 et 360 ou entre 0 et 40 (rouge)

Pour chaque image tu auras une liste de N valeurs caracteristiques des couleurs de l'image.


Remarque: La valeur de Hue seule ne suffit pas car les couleurs noir/gris/blanc n'y sont pas représentées. Solution: Lorsque la composante S devient faible (<20%), on s'interesse alors a la composante V: V=0% noir --> V=100% blanc

[amiine]

salut à tous, je prend tous vos conseils avec le plus grand sérieux et je compte travailler avec, jusqu'à ceque je marquerais ce problème comme résolu merci beaucoups !

[pseudocode]

J'ai appliqué mon algo sur ton image d'exemple et voila ce que j'obtient:
(les valeurs ont été normalisées pour faire un total de 100 puis arrondies)

Code :

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

1
2
3
4
 
[0, 0, 0, 0, 0, 0, 3, 25, 0, 0, 0, 0] [ 61, 0, 1, 3, 5]
 \______________     ______________/   \____      ___/
                 HUE                         GRAY

On remarque une pointe a 25 pour les Hue dans l'intervalle 210°-230° (bleu)
et une autre pointe a 61 pour les Gray dans l'intervalle 0%-20% (noir)

Etonnant, non ?

[amiine]

Merci beaucoup Pseudo, l'idée de passer à un autre espace de couleurs est la bonne je crois, reste à prouver que HSV est le meilleur choix (personnellement je crois que si), mais pour mon projet (en retard) j'utilise C++builder, et avant de vous casser la tete avec un nouveau problème j'ai beau essayé, de travailler avec l'espace HSV, mais en vain, dernière question comment avez vous fais, Pseudocode pour obtenir ces résultats là ?!

[pseudocode]

Désolé mais je n'ai pas codé mon algo en C++Builder mais en Java. Enfin bon, ca ne change pas grand chose.

Phase 1: Convertir les valeurs RGB en HSV. L'algo est dispo sur wikipedia (voir mes posts precedents). Bon, en Java l'ago est deja codé (Color.RGBtoHSB) , mais je l'ai réécrit pour l'exemple

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
 
public static double[] convertRGBtoHSV(int r, int g, int b) {
	double max = Math.max(r, Math.max(g,b));
	double min = Math.min(r, Math.min(g,b));
 
	double h=0;
	if (max==min) h=0;
	else if (max==r && g>=b) h = 60*(g-b)/(max-min)+0;
	else if (max==r && g<b) h = 60*(g-b)/(max-min)+360;
	else if (max==g) h = 60*(b-r)/(max-min)+120;
	else if (max==b) h = 60*(r-g)/(max-min)+240;
 
	double s=0;
	if (max!=0) s=1-min/max;
 
	double v=max/255;
 
	/* H entre 0 et 359, s et v entre 0 et 1 */
	return new double[] {h,s,v};
}

Phase 2: Evaluer chaque pixel de l'image et mettre a jour les 2 tableaux Hue[] et Gray[]

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
 
int gray[] = new int[5];
int hue[] = new int[12];
 
public void evaluatePixel(int r, int g, int b) {
	double[] hsv = convertRGBtoHSV(r, g, b);
	double h = hsv[0];
	double s = hsv[1];
	double v = hsv[2];
 
	if (s<0.2) {
		int idx = (int)(5*v);
		if (idx==5) idx=4;
		gray[idx]++;
	} else {
		int idx = (int)(12*h/360);
		if (idx==12) idx=11;
		hue[idx]++;
	}
}

Voila, les 2 tableaux sont remplis.
Apres, on peut les normaliser pour faciliter les comparaisons.

[hanane78]

Bonjour pseudo
si je suivre votre algorithme je peux avoir le nombre le classe pour chaque image donc c'est une methode non superviser pour faire la segmentation

Amicalement
Hanane

[hanane78]

Phase 2: Evaluer chaque pixel de l'image et mettre a jour les 2 tableaux Hue[] et Gray[]

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
 
int gray[] = new int[5];
int hue[] = new int[12];
 
public void evaluatePixel(int r, int g, int b) {
	double[] hsv = convertRGBtoHSV(r, g, b);
	double h = hsv[0];
	double s = hsv[1];
	double v = hsv[2];
 
	if (s<0.2) {
		int idx = (int)(5*v);
		if (idx==5) idx=4;
		gray[idx]++;
	} else {
		int idx = (int)(12*h/360);
		if (idx==12) idx=11;
		hue[idx]++;
	}
}

Voila, les 2 tableaux sont remplis.
Apres, on peut les normaliser pour faciliter les comparaisons.

j'ai pas bien compris la deuxieme phase
apres la construction des 2 tableaux c'est votre objectif
Merci d'avence

[pseudocode]

On parcours simplement tous les pixels de l'image et on augmente le compteur correspondant.

On obtient donc un vecteur à 17 composantes (12 couleurs + 5 niveaux de gris). A ce stade il faut normaliser le vecteur, c'est a dire diviser chaque composante par le nombre total de pixels.

[hanane78]

Merci pour votre reponse

j'ai fait ce test sous matlab pour la premiere phase

Code :

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

1
2
3
4
5
6
 
I=imread('originale.jpg');
Img=double(rgb2hsv(I));
H = Img(:,:,1);
S = Img(:,:,2);
V = Img(:,:,3);

c'etait une image de synthese

mais vous disiez vous nous allons avoir 17 composante (12 couleur et 5 NG)
ce resultat est tjrs vrai pour chaque image ou bien pour votre image

quant à condition que vous avez fait dans votre code
vous faites S<0.2 prq ???

j'ai pas bien compris cette parti

Code :

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

1
2
3
4
5
6
7
8
9
10
 
if (s<0.2) {
		int idx = (int)(5*v);
		if (idx==5) idx=4;
		gray[idx]++;
	} else {
		int idx = (int)(12*h/360);
		if (idx==12) idx=11;
		hue[idx]++;
	}

Merci Bien

[pseudocode]

mais vous disiez vous nous allons avoir 17 composante (12 couleur et 5 NG)
ce resultat est tjrs vrai pour chaque image ou bien pour votre image

on peut creer autant de compsante que l'on veut. J'ai choisi "12+5" au hasard.

quant à condition que vous avez fait dans votre code
vous faites S<0.2 prq ???
j'ai pas bien compris cette parti

Ah... je l'ai expliqué au post #10:

La valeur de Hue seule ne suffit pas car les couleurs noir/gris/blanc n'y sont pas représentées.

Solution: Lorsque la composante S (saturation) devient faible (<20%), on s'interesse alors a la composante V (value) :

V=0% noir --> V=100% blanc

[hanane78]

voici cette exemple sous matlab

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
close all;clear all;clc;
I=imread('originale.jpg');
Img=double(rgb2hsv(I));
H = Img(:,:,1);
S = Img(:,:,2);
V = Img(:,:,3);
 
 if (S < 0.2) 
  idx = 5*V
 
else 
idx = 12*H/360
end

mais ce code ne donne seulement une matrice
et pour votre algorithime il doit avoir un vecteur
NB :je sais que ce probleme de matlab mais seulement juste une explication de votre l'algorithme