Bonjour,

voilà trois classes permettant d'étiqueter des composantes connexes à l'aide de plusieurs méthodes :
- Itérative => Classique et rapide.
- Récursive => Le plus rapide, mais avec un TRES gros risque de StackOverFlow, donc a éviter.
- Fifo => La version récursive implémentée avec une file.
- Union-Find (la version de PseudoCode dans ma plate-forme).

J'ai fait des tests et la méthode la plus rapide est FiFo dans la TRES grande majorité des cas. Il faut éviter la récursive pour les problèmes de débordement, elle n'est là que pour le coté pédagogique.
De même la version Union-Find est très belle, mais très lente : environ 5 à 8 fois plus lente que la FiFo (calculé de manière empirique).



Voici un petit exemple d'utilisation :
Code java : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
EightConnex = true ; // On travaille en 8-connexité.
ConnectedComponentLabeling ccl = new FifoCcl() ;
ccl.Label(image, 0, EightConnex, null) ; // On calcule (étiquette) les composantes connexes.  On ne prend pas en compte la couleur noire car c'est le fond. Mettre -1 pour caractériser TOUTE la texture.
int[][] Carte = ccl.Labels() ; // la carte contenant la numérotation de chaque composante.
int[] Sizes = ccl.Sizes() ; // Le tableau contenant les tailles de composantes.





Tout d'abord, voici l'interface permettant de s'abstraire un peu de la méthode :
Code java : 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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
import java.awt.image.BufferedImage;
import java.util.List;
 
import utils.times.Chronometer;
 
/**
 * <p>Description : Interface qui permet de savoir si une classe peut calculer le nombre de composantes connexes
 * presentes dans une image. Il est conseille d'utiliser FifoCcl ou IterativeCcl.<br>
 * UnionFindCcl est tres lent et RecursiveCcl genere un StackOverFlow si une composante est trop grande.</p>
 * <p>Package(s) required: imageTiTi, utils.</p>
 * <p>Copyright: Copyright (c) 2007-2011.</p>
 * <p>Laboratories/Teams: CMM (Mines-ParisTech/ENSMP), I&M (ex LXAO) LSIS.</p>
 * <p>Updates:<br>
 * 11 Avril 2010 => Modification des methodes Separate* afin de pouvoir eventuellement passer une image a decouper.<br>
 * 19 Janvier 2010, 1.1 => Ajout des methodes Label(*) avec pour types d'entree : DV, int[][] et int[][][].<br>
 * 06 Aout 2009 => Creation.</p>
 * 
 * @author Guillaume THIBAULT
 * @version 1.1
 */
 
public interface ConnectedComponentLabeling
{
 
 
/** Calcule le nombre de composantes connexes dans l'image.
 * @param Original L'image dans laquelle on doit compter les composantes connexes.
 * @param Fond Couleur du fond, donc a ne pas prendre en compte.
 * @param HuitConnexe Booleen qui permet de savoir si le calcul se fait en quatre ou huit connexites.
 * @param Chrono Le chronometre pour mesurer la duree.
 * @return Le nombre de composantes connexes de l'image.*/
public int Label(BufferedImage Original, int Fond, boolean HuitConnexe, Chronometer Chrono) ;
 
/** Calcule le nombre de composantes connexes dans l'image.
 * @param Original Le tableau dans lequel on doit compter les composantes connexes.
 * @param Fond Couleur du fond, donc a ne pas prendre en compte.
 * @param HuitConnexe Booleen qui permet de savoir si le calcul se fait en quatre ou huit connexites.
 * @param Chrono Le chronometre pour mesurer la duree.
 * @return Le nombre de composantes connexes de l'image.*/
public int Label(int[][] Original, int Fond, boolean HuitConnexe, Chronometer Chrono) ;
 
/** Calcule le nombre de composantes connexes dans l'image.
 * @param Original Le tableau dans lequel on doit compter les composantes connexes.
 * @param Fond Couleur du fond, donc a ne pas prendre en compte.
 * @param TwentySixConnex Booleen qui permet de savoir si le calcul se fait en six ou vingt six connexites.
 * @param Chrono Le chronometre pour mesurer la duree.
 * @return Le nombre de composantes connexes de l'image.*/
public int Label(int[][][] Original, int Fond, boolean TwentySixConnex, Chronometer Chrono) ;
 
/** Calcule le nombre de composantes connexes dans l'image mais ne compte que les composantes ayant une surface superieure a
 *  Threshold.
 * @param Threshold Surface minimum que doit avoir une composante connexe afin d'etre comptabilisee. 
 * @return Le nombre de composantes connexes de l'image.*/
public int NumberOfConnectedComponent(int Threshold) ;
 
 
/** Methode qui renvoit le nombre de composantes connexes denombrees lors du dernier appel de la methode Label.
 * @return Le nombre de composantes.*/
public int NumberOfConnectedComponent() ;
 
 
/** Method which return array of labels.
 * @return Array.*/
public int[][] Labels() ;
 
/** Method which return 3D array of labels.
 * @return Array 3D.*/
public int[][][] Labels3D() ;
 
 
/** Method which return sizes of connected components.
 * @return Array.*/
public int[] Sizes() ;
 
}