Discussion :

[Moux88]

Bonjour à tous ,

J'ai 8 tableaux composés chacun de 3 lignes et 21 colonnes. (tab1......tab8)
chaque colonne de 3 valeurs représente la valeur d'un pixel en RGB.

ex:
tab1=
1 4 7
2 5 8
3 6 9

tab2 =
10 1 54
11 2 14
12 3 87
J'aimerais pour chaque tableau, en les comparant un à un, savoir si ils ont des pixels en commun.
Si oui j'incrémente un compteur propre à un tableau (J'ai donc 8 compteur), si non -> rien.
Ici ces deux tableaux ont un pixel en commun (1,2,3)

Donc le compteur du premier tableau serait cpt1 = 1, et celui du deuxième serait cpt2 = 1.
Je veux donc que chaque tableau soit comparé aux 7 autres pour avoir 8 compteurs au final.

Je pensais donc partir sur une méthode avec des if :

Code :

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

1
2
3
4
5
6
 
for(int i = 0; i<21;i++){
    if((tab1[0][i]==tab2[0][i]) && (tab1[1][i]==tab2[1][i]) && (tab1[2][i]==tab2[2][i])){
        cpt1++;
    }
}

Mais comme mes tableaux ont des noms différents je devrais faire 7 if pour chaque tableau, donc 56 if :/ Ce qui me fait un code énorme

Avez-vous une autre solution à me proposer ?

Merci beaucoup

[joel.drigo]

Salut,

La méthode Arrays.equals(int[], int[]) permet de comparer 2 tableaux : on considère qu'ils sont égaux s'ils ont la même taille et les mêmes valeurs dans le même ordre.

Code :

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

1
2
3
4
5
int[] a= {1,2,3};
int[] b= {1,2,3};
int[] c= {3,2,1};
System.out.println( Arrays.equals(a, b) );
System.out.println( Arrays.equals(a, c) );

Affiche true puis false.

Si tu fais if ( Arrays.equals(a,b) && Arrays.equals(a,c) ) tu peux tester l'égalité entre 3 tableaux.

Ensuite, si tu as un tableau à 2 dimensions, c'est comme si c'était un tableau de tableaux, donc tu peux écrire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int[][] array1 = /*...*;
int[][] array2 = /*...*/;
 
boolean eq=false;
if ( array1.length==array2.length) {
   eq=true;
   for(int i=0; eq && i<array1.length; i++ ) {
         eq = Arrays.equals( array1[i], array2[i] ) ;
   }
}
System.out.println("Tableaux égaux : " + eq);

(Tu as aussi une méthode Arrays.deepEquals() qui fait ça toute seule, mais tu ne pourras pas t'en servir pour compter les pixels en commun).

[Moux88]

Alors merci beaucoup je ne connaissez pas cette méthode je peux essayer de commencer avec ça.

Cette méthode ne renvoi "True" que si les tableaux ont les valeurs dans le même ordre.

Pourtant je voudrais que la détection se fasse même si les valeurs sont dans le désordre :

Code :

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

1
2
3
 
int[][] array1 = {{1,2,3},{12,4,5}};
int[][] array2 = {{1,2,3},{9,4,8}};

ici j'ai bien un pixel en commun mais ça me renvoi false

En tout cas merci je vais commencer par chercher dans ce coin là

[JohannL]

Une piste intéressante serait de te créer une classe qui représente un pixel et qui contienne les 3 valeurs, pour obtenir 8 tableaux de 21 pixels.
Ensuite tu peux surcharger la méthode Object#Equals (et Object#hashcode au passage) pour que 2 pixels avec les mêmes valeurs soit considérés comme égales.
Enfin, tu pourras utiliser la méthode Arrays#binarySearch pour rechercher chaque valeur dans chaque tableau, ou passer sur des List et utiliser List#contains plutôt.

[joel.drigo]

Code :

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

1
2
3
 
int[][] array1 = {{1,2,3},{12,4,5}};
int[][] array2 = {{1,2,3},{9,4,8}};

ici j'ai bien un pixel en commun mais ça me renvoi false

Non, mais il ne faut utiliser Arrays.equals() que pour le tableau de composantes évidemment. Pour le tableau de pixels, tu es obligé de le parcourir. Là, ça te rend false parce que {12,4,5} est différent de {9,4,8}.

If faut que tu parcours le premier tableau, et que tu parcours ensuite le second, comme ça, par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int[][] array1 = {{1,2,3},{12,4,5}};
int[][] array2 = {{1,2,3},{9,4,8}};
for(int i=0; i<array1.length; i++) {
 
      for(int[] pixel2 : array2 ) {
            if ( Arrays.equals(array1[i], pixel2) ) {
                 System.out.println("Le pixel de position " + (i+1) + " dans le premier tableau se trouve aussi dans le second");
                 break;
            }
      }
 
 
}

[Moux88]

Merci pour vos réponses. Je ne suis pas encore très à l'aise avec les classes je n'en ai qu'une pour le moment. Je vais regarder ducoup merci JohannL

Et je ne comprends pas ce morceau :

Code :

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

1
2
3
4
5
 
  for(int[] pixel2 : array2 ) {
            if ( Arrays.equals(array1[i], pixel2) ) {
            }
   }

Je ne savais pas qu'on pouvais initialiser un tableau dans un for
Ducoup si on traduit ça veut dire ;

Pour tableau "pixel2" allant de ? à taille tableau array2
Faire Si l'élément sélectionné est égal au pixel choisi
Alors (la suite...)

c'est bien ça ?

[joel.drigo]

Et je ne comprends pas ce morceau :

Code :

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

1
2
3
4
5
 
  for(int[] pixel2 : array2 ) {
            if ( Arrays.equals(array1[i], pixel2) ) {
            }
   }

Il s'agit d'un forEach. Pout tout objet "object" itérable de T (dont le type est une classe implémentant directement ou indirectement Iterable<T> ou un tableau T[]), on peut écrire :

Code :

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

1
2
for(T item : object) {
}

Ce qui revient à écrire pour T implémentant Iterable<T> :

Code :

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

1
2
3
for(Iterator<T> iterator = object.iterator(); iterator.hasNext(); ) {
      T item = iterator.next();
}

Et pour un tableau,

Code :

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

1
2
3
for(int i=0; i<object.length; i++) {
    T item = object[i];
}

Si T est un tableau de int (soit int[]), ce qui est le cas avec un int[][], qui est un tableau de int[], on peut écrire :

Code :

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

1
2
3
4
int[][] array = /*...*/
for(int i=0; i<array.length; i++) {
       int[] ligne = array[i];
}

Donc on peut écrire :

Code :

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

1
2
3
int[][] array = /*...*/
for(int[] ligne : array) {
}

Ce qui revient au même, sauf que dans le second cas, on n'a pas de variable i, donc on ne peut connaitre l'index (la position du tableau ligne dans le tableau array). Quand on n'a pas besoin de la connaitre, on peut s'en passer et simplifier l'écriture de la boucle par un forEach.

D'ailleurs, on peut écrire, de même :

Code :

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

1
2
3
4
5
int[][] array = /*...*/
for(int[] ligne : array) {
   for(int valeur : ligne) {
   }
}

[Moux88]

Ah super merci
bon j'essaye tout ça alors !

[Moux88]

Bonjour,

J'ai donc adapté votre code au miens merci beaucoup
Ce qui me donne :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
      int compteur =0 ;
      for(int i=0; i<tab1.length; i++) {
          for(int[] pixel2 : tab2 ) {
              if ( Arrays.equals(tab1[i], pixel2) ) {
                  compteur++;
                  break;
                }
            }
        }
      System.out.println("Common Pixels : "+ compteur);

j'obtiens donc entre le 1er et le deuxième tableau le nombre de pixels en commun

Cependant j'ai 8 tableaux (tab1 tab2 tab3 tab4....tab8), je dois donc appliquer ce code 7 fois pour chaque tableau, donc 56 fois.
J'essaye de créer une méthode mais je n'ai pas trop d'idée car mes tableaux n'ont pas le même nom.

Avez-vous une idée ?
J'ai fait ça pour la première comparaison mais ma méthode est vraiment très répétitive, désolé je ne suis pas très à l'aise encore avec les méthodes :

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
45
46
47
48
49
 
    public void Compare_Pixels(){
      int compteur =0 ;
      for(int i=0; i<tab1.length; i++) {
          for(int[] pixel2 : tab2 ) {
              if ( Arrays.equals(tab1[i], pixel2) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel3 : tab3 ) {
              if ( Arrays.equals(tab1[i], pixel3) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel4 : tab4 ) {
              if ( Arrays.equals(tab1[i], pixel4) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel5 : tab5 ) {
              if ( Arrays.equals(tab1[i], pixel5) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel6 : tab6 ) {
              if ( Arrays.equals(tab1[i], pixel6) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel7 : tab7 ) {
              if ( Arrays.equals(tab1[i], pixel7) ) {
                  compteur++;
                  break;
                }
            }
          for(int[] pixel8 : tab8 ) {
              if ( Arrays.equals(tab1[i], pixel8) ) {
                  compteur++;
                  break;
                }
            }
        }
      labelComplexValue.setText("Common Pixels : "+ compteur);
    }

Merci

[joel.drigo]

Si tu fais une méthode, c'est justement pour pouvoir l'appeller plusieurs fois, avec différents tableaux en paramètre.

Si tu as une méthode, par exemple qui compte le nombre d'occurance d'une valeur dans un tableau :

Code :

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

1
2
3
4
5
6
7
public static int compte(int[] tab, int v) {
   int n=0;
   for(int i : tab) {
       if ( i==v ) n++;
   }
   return n;
}

Tu peux l'appeller :

Code :

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

1
2
3
4
5
6
7
8
9
int[] tab1 = {1,2,3};
int[] tab2 = {1,2,1};
int[] tab3 = {1,1,1};
int[] tab5 = {2,3,4};
int n = compte(tab1, 1);
n += compte(tab2, 1);
n += compte(tab3, 1);
n += compte(tab4, 1);
System.out.println( "Le nombre de 1 dans tous les tableaux est : " + n);

Si en plus tu as la possibilité de mettre les tableaux eux-même dans un tableau, ou tout Iterable, tu pourras faire une boucle :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int[][] tabs = {
   {1,2,3},
   {1,2,1},
   {1,1,1},
   {2,3,4}
};
 
int n=0;
for(int[] tab : tabs) {
   n += compte(tab, 1);
}
System.out.println( "Le nombre de 1 dans tous les tableaux est : " + n);

[Moux88]

Merci beaucoup c'est cette notion de paramètre qu'il me manquait.
Je réfléchis avec ça alors

Ah je suis content merci grâce à vous je viens de réaliser ma première méthode avec un return c'est un grand pas pour moi :
La voici :

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
 
    public static int Compare(int [][] tab){
        int compteur = 0;
        for(int i=0;i<tab1.length;i++){
            for(int[] pixel : tab){
                if( Arrays.equals(tab1[i], pixel)){
                    compteur++;
                    break;
                }
            }
        }
        return compteur; 
    }
 
    public static void Compare_Pixels(){
      int compteur = Compare(tab2);
      labelComplexValue.setText("Common Pixels : "+ compteur);
    }