Discussion :

[Moux88]

Bonjour,

Je cherche à connaître la couleur la plus présente dans une image.

En parcourant chaque pixel de mon image j'aimerais obtenir les valeurs du pixel (R,G,B) qui est en plus grand nombre dans l'image.
Voici ce que j'ai fait mais le code ne s'arrête jamais. (enfin j'ai attendu 6 min maximum et ça chargeait)
Je pense que ma quadruple boucle est trop longue.

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
33
34
35
36
37
38
39
40
41
42
43
44
 
public static void Main_Color(String path_Image) throws IOException{
        int cpt=0;
        listcpt.add(cpt);
        System.out.println(listcpt);
        imgglobal = ImageIO.read(new File("C:\\Users\\guill\\"+path_Image));
        for(int a =0; a< imgglobal.getWidth();a++){
            for(int b =0; b< imgglobal.getHeight(); b++){
                int p = imgglobal.getRGB(a, b);
                int r = (p>>16)&0xff;
                int g = (p>>8)&0xff;
                int bl = p&0xff;
                listpx.add(r);
                listpx.add(g);
                listpx.add(bl);
                System.out.println(listpx);
 
                for(int i =0; i< imgglobal.getWidth();i++){
                    for(int j =0; j< imgglobal.getHeight(); j++){
                        p = imgglobal.getRGB(i, j);
                        r = (p>>16)&0xff;
                        g = (p>>8)&0xff;
                        bl = p&0xff;
                        System.out.println("ok");
 
                        if(r==listpx.get(0) && g==listpx.get(1) && bl==listpx.get(2)){
                            cpt++;
                            System.out.println("+1");
                        }
                    }
                }
                if(cpt > listcpt.get(0)){
                    listcpt.clear();
                    listcpt.add(cpt);
                    listpxSave = listpx;
                }
                cpt = 0;
                listpx.clear();
            }
        }
        System.out.println("The main color is : " + listpxSave);
        System.out.println("This color appears " + listcpt.get(0)+ " times");
 
    }

Je prends le premier pixel et je le compare a tous les pixels y compris à lui même. Une fois terminé je prends le deuxième pixel et je le compare à tous les pixels y compris au premier et à lui même.

Avez vous une idée ?
Merci beaucoup

[tchize_]

ouais c'est une catastrophe algorithmique ton truc

D'abord la base: tu recois déjà un nombre int représentant le RGB, tu le décompose, tu décompose le pixel cible et tu compare membre à membre le r, le g et le b. Compare directement les integer:



int p = imgglobal.getRGB(a, b);
//

int q = imgglobal.getRGB(i, j)
if (p==q) {
// les mêmes
}

Ensuite, tu compare chaque point à l'ensemble des autres points. C'est faux. Compare le à l'ensemble des points "suivant". Si la couleur est aussi présente avant, elle a déjà fait l'objet d'un comptage et en fait son re-comptage est inutile:

Code :

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

1
2
3
 
                for(int i =a; i< imgglobal.getWidth();i++){
                    for(int j =(i==a?b:0)0; j< imgglobal.getHeight(); j++){

Enfin, d'une manière générale, on n'a pas besoin de double parcours pour faire un comptage, sauf si le scope de données est impraticable. Mais ici on parle d'une image qui tiens en mémoire, donc compte toutes les valeurs d'une traite.

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
        Map<Integer,Integer> comptage = new HashMap<>();
        int couleurMax=0;
        int cptMax=0;
 
        for(int a =0; a< imgglobal.getWidth();a++){
            for(int b =0; b< imgglobal.getHeight(); b++){
                int couleur = imgglobal.getRGB(a, b);
                int currentCount;
                if (comptage.contains(couleur)){
                    currentCount = comptage.get(couleur)+1;
                } else {
                    currentCount=1;
                }
                comptage.put(couleur,currentCount);
                if (currentCount>cptMax){
                   cptMax = currentCount;
                   couleurMax = couleur;
                }

Il y a probablement moyen de faire plus propre avec les collecteur et java 8 dans l'api stream et il y a surement des algos plus avancés qui évitent la création d'une map intermédiare et son coût. Mais éviter déjà la lecture en n² des pixel c'est une fort amélioration

[Moux88]

Bonjour, merci beaucoup.

Ok je vois j'ai pensé beaucoup trop compliqué. En effet, comparer directement les deux pixels est plus rapide et une simple boucle parait plus évident maintenant.

Merci beaucoup je vais essayer tout ça .

En ce qui concerne la version java je ne peux pas changer c'est pour le travail et je dois continuer d'utiliser java 7, mais merci quand même j'en prends compte

Merci beaucoup

[Moux88]

Bon j'ai abandonné mon idée.
J'ai fait un truc qui fonctionne mais je n'ai pas exactement le bon résultat.

Si je veux pas exemple la couleur principale de l'image d'un bateau blanc en tout petit au centre de l'image sur une gigantesque mer bleue.
Le résultat est "bleu"

Mais il y a tellement de bleu différent que c'est impossible 'avoir une couleur primaire.

J'ai quelques idées mais je ne le ferais pas je dois passer à autre chose.
Si jamais ça vous intéresse dite le moi ^^.

Merci pour votre aide en tout cas