4.3.Implémentation du prétraitement
Ecrit en code java, le procédé de
prétraitement se présente comme suit :
/**
*
* Classe du Prétraitement
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June, 2012, 09:19
*
*/
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
import java.awt.geom.A ffineTrans form;
import java.awt.image.A ffineTrans formOp;
import javax.swing.JFileChooser;
public class Pretraitement{
/**
* Constructeur de la classe Pretraitement
* La méthode reçoit le fichier image au
format jpeg.
* Ensuite la méthode reduit la taille de l'image
avant de le binariser
* L'image réduite et binarisée est
retournée par la méthode @see getImageRB
*/
Bu fferedImage image,imgRB; String filename;
Pretraitement() throws IOException{
JFileChooser choix = new JFileChooser();
choix.setToolTipText("Sélectionnez l'image du
tableau à reconnaître "); i f (choix.showOpenDialog(null) ==
JFileChooser.OPEN_DIALOG){ filename =choix.getSelectedFile().getAbsolutePath();
image=ImageIO.read(new File(filename));}
this.imgRB=binarisation(reduireTaille(image));
}
/**
* Méthode qui réduit la taille de
l'image.
* La méthode prend en entrée une image
temporaire.
* Ensuite la méthode calcule la valeur du ratio
de réduction.
* Après quoi,l'image d'entrée est
reduite.
* @param img l'image temporaire représentant
l'image d'entrée.
* @return imgReduite */
public Bu fferedImage reduireTaille(Bu fferedImage img)
throws IOException{
float ratio,a,b; int e, f;
ratio=(float)1;
e=300; f=300;
a=img.getwidth(); b=img.getHeight();
//Calcul du rapport de taille:
i f ((a*300)>(300*b)){
ratio=300/a;
}else{
ratio=300/b;
}
i f ((b<=300)&&(a<=300)){
e=(int)a;f=(int)b; ratio=(float)1;
}
//Reduction de la taille de l'image:
Bu fferedImage imgReduite=new Bu fferedImage(e,
f,img.getType());
AffineTransform
retailler=A ffineTrans
form.getScaleInstance(ratio,ratio);
int
interpolation=AffineTransformOp.TYPE_BICUBIC;
*
A ffineTrans formOp retaillerimage=new A ffineTrans
formOp(retailler,interpolation);
retaillerimage.filter(img,imgReduite); return
imgReduite;
}
/**
* Méthode qui binarise l'image.
* La méthode prend en entrée une image
temporaire.
* Ensuite la méthode recherche le niveau de
couleur maximal de
l'image.
69
Après quoi,l'image d'entrée est
binarisée.
* @param img l'image temporaire représentant
l'image d'entrée.
* @return imageBinarise
*/
public Bufferedlmage binarisation(Bufferedlmage img)
throws
IOException{
int[][] pixel=new
int[img.getHeight()][img.getwidth()];
int[] rgb=new int[3];
writableRaster trame=img.getRaster();
int seuil=0;
//Recherche du niveau de couleur maximal de
l'image.
for (int i=0;i<img.getHeight();i++){
for (int j=0;j<img.getwidth();j++){
trame.getPixel(j,i,rgb);
pixel[i][j]=rgb[0]+rgb[1]+rgb[2];
i f (pixel[i][j]>seuil){
seuil=pixel[i][j];
}
}
}
//Calcul du seuil de binarisation de
l'image:
seuil=((10*seuil)-1-Math.abs(seuil-765))/11;
//Binarisation de l'image:
Bufferedlmage imageBinarise = new
Bu fferedlmage(img.getwidth(),img.getHeight(),
Bufferedlmage.TYPE_INT_RGB);
writableRaster
trame2=imageBinarise.getRaster();
for (int
i=0;i<imageBinarise.getHeight();i++){
for (int
j=0;j<imageBinarise.getwidth();j++){
i f (pixel[i][j]<seuil){
}else{
}
}
rgb[0]=0;rgb[1]=0;rgb[2]=0;
trame2.setPixel(j,i,rgb);
rgb[0]=255;rgb[1]=255;rgb[2]=255;
trame2.setPixel(j,i,rgb);
}
return imageBinarise;
}
/**
* Méthode qui retourne l'image après tout
le processus de
* prétraitement.
* @return imgRB.
*/
}
Bufferedlmage getlmageRB(){ return
this.imgRB;
}
4.4. Implémentation du réseau de
neurones
4.4.1. Quelques considérations d'ordre
techniques
De prime abord, avouons que l'implémentation
d'un réseau de neurones n'est pas du tout aussi simple qu'on puisse
l'imaginer. Cela est d'autant plus vrai que, dans la réalité,
la
70
configuration spatiale même du réseau
(une configuration en 3D !) n'est pas facile à mettre en oeuvre lorsque
l'on travaille avec des données dans un espace 2D.
Cela étant, afin de matérialiser notre
réseau dans des dimensions acceptables (similaires au 3D), nous avons
recouru à des objets disponibles dans le langage Java, à savoir :
les conteneurs.
En fait, en Java, les conteneurs ne sont rien
d'autres que des objets permettant de stocker soit d'autres objets ou des
scalaires. De plus, il sied de noter que les classes conteneurs ne peuvent
stocker que des références sur des objets. Parmi les conteneurs
les plus utilisés en Java (ou offerts dans les bibliothèques du
langage Java), nous trouvons : les énumérateurs (Enumerator), les
vecteurs (Vector), les itérateurs (Iterator), les listes (ArrayList) ,
les tableaux, etc. De tous ces conteneurs, nous avons choisi d'utiliser les
tableaux pour implémenter notre réseau, et cela, pour les raisons
suivantes :
- Un tableau peut stocker directement des scalaires
aussi bien que des références sur des objets.
- Il est bien plus facile de créer un tableau
et d'accéder à n'importe quel de
ses
éléments.
4.4.2. Implémentation du neurone de la
Rétine
Ecrit en code Java, un neurone de la Rétine se
présente de la manière suivante :
/**
*
* Classe du neurone de la retine
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June,2012, 09:19
*
*/
public class Neurone{
int[] entree; //variable d'entrée du
neurone
int sortie; //variable de sortie du neurone
/**
* Constructeur de la classe Neurone
* La méthode prend en entrée un tableau de
trois entiers représentant
* les trois couleurs RVB d'un pixel de
l'image.
* Ensuite la méthode fixe la valeur de sortie du
neurone en utilisant
* la valeur retournée par la méthode @see
setSortie
* @param int[]ent le tableau des couleurs RVB
(rouge,vert,bleu) */
Neurone (int[] ent){ this.entree=new int[3]; for (int
i=0;i<3;i++){ this.entree[i]=ent[i]; }
sortie=0;
sortie=setSortie(entree);
71
}
~**
* Méthode qui retourne les valeurs
d'entrée du neurone
* La méthode prend en entrée un tableau
de trois entiers représentant
* les trois couleurs RVB d'un pixel de
l'image.
* Ensuite la méthode fixe la valeur
d'entrée du neurone en lisant
* les trois entiers RVB du pixel
d'entrée.
* @param int[]p le tableau des couleurs RVB
(rouge,vert,bleu) du pixel p
* @return entree
*1
public int[] getEntree(int[] p){ for (int
i=0;i<3;i++){ this.entree[i]=p[i]; }return entree;
}
~**
* Méthode qui calcule la valeur de sortie du
neurone
* La méthode prend en entrée un tableau de
trois entiers représentant
* les trois couleurs RVB d'un pixel de
l'image.
* Ensuite la méthode fixe la valeur
d'entrée du neurone en lisant
* les trois entiers RVB du pixel
d'entrée.
* @param int[]pix le tableau des couleurs RVB
(rouge,vert,bleu) du pixel pix
* @return sortN
*1
public int setSortie(int[] pix){ int[] sort;
int sortN;
sort=new int[3]; sortN=0; sort=getEntree(pix); for (int
i=0;i<3;i++){
sortN+=sort[i];
}
i f (sortN==0){
sortN=1;
}else {
sortN=0;
}
return sortN;
}
~**
* Méthode qui retourne la valeur de sortie du
neurone
* Ensuite la méthode fixe la valeur de sortie en
la calculant à partir
* de la méthode @see setSortie
* les trois entiers RVB du pixel
d'entrée.
* @param n le neurone pour lequel l'on désire
obtenir la valeur de sortie
* @return sortieN
*1
public int getSortie(Neurone n){ int sortieN;
sortieN=setSortie(n.entree); return sortieN;
}
}
4.4.3. Implémentation de la couche
`'Retine»
Ecrite en code Java, la couche de la rétine se
présente comme suit : ~**
*
* Classe de la couche Rétine
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June,2012, 09:19
*
*/
import java.awt.image.*;
import java.io.*;
72
public class Retine{
Neurone nR; //variable du neurone de la
retine
public Neurone[][] neuR;//variable de la matrice des
neurones de la
retine
Neurone[][] nsR; //variable de la matrice d'un certain
nombre de neurones de la rétine
public static Bufferedzmage image,imageTypee;//variables
de l'image temporaire.
writableRaster trame;//variable de la trame de l'image
d'entrée. int [][]pixel,y; //variable de la matrice
d'entiers.
int [] rgb; //variable du tableau de composantes rvb de
l'image d'entrée.
/**
* Constructeur de la classe Retine
* La méthode crée d'abord une matrice de
300x300 neurones correspondant
* aux pixels de l'image d'entrée.Ensuite,
après avoir lu l'image d'entrée,
* cette dernière est transférée
vers une zone d'image temporaire où elle est
* typée afin de pouvoir en extraire la trame
de pixels qui la composent.
* Après lecture de la trame de pixels, il y a
extraction des composantes rvb
* de chaque pixel et transfert de ces composantes vers
une matrice d'entiers
* qui servira de paramètre à la
méthode du constructeur de la classe @see Neurone.
*
*/
Retine() throws zOException{
neuR=new Neurone[300][300];
Pretraitement p=new Pretraitement();
image=p.getzmageRB();
trame=image.getRaster();
pixel=new int[image.getHeight()][image.getwidth()];
rgb=new
int[4];
int[] RVB=new int[3];
for (int i=0;i<300;i++){
for (int j=0;j<300;j++){
trame.getPixel(i,j,rgb);
RVB[0]=rgb[0];
RVB[1]=rgb[1];
RVB[2]=rgb[2];
neuR[i][j]=new Neurone(RVB);
}
}
}
/**
* Méthode qui retourne un neurone se trouvant
à la position (posNRl,posNR2).
* @param posNRl l'abscisse de la position du neurone
dans la Retine
* @param posNR2 l'ordonnée de la position du
neurone dans la Retine
* @return Neurone
*/
public Neurone getNeuroneR(int posNRl,int
posNR2){
nR=neuR[posNR2][posNRl];
return nR;
}
/**
* Méthode qui retourne une matrice de neurones
nombreNRl x nombreNR2.
* @param nombreNRl le nombre de colonnes de la
matrice de neurones de la Retine
* @param nombreNR2 le nombre de lignes de la matrice de
neurones de la Retine
* @return Neurone[H] []
*/
public Neurone[][] getNeuronesR(int nombreNRl,int
nombreNR2){
nsR=new Neurone[nombreNR2][nombreNR1];
for (int i=0;i<nombreNRl;i++){
for (int j=0;j<nombreNR2;j++){
nsR[i][j]=neuR[i][j];
}
}return nsR; }
73
}
4.4.4. Implémentation du neurone de Gradient
Ecrit en Java, un neurone du Gradient se présente
comme suit :
/**
*
* Classe du neurone du Gradient
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
*
*/
import java.io.*;
public class Ngrad{
public Neurone[][] entree;//variable d'entrée du
neurone public int sortie; //variable de sortie du neurone public int[][] E;
int sortN=0;int v=0,w=0;
/**
* Constructeur de la classe Ngrad
* La méthode prend en entrée un tableau de
neuf entiers représentant
* les neuf sorties des neurones de la
Retine.
* Ensuite la méthode fixe la valeur de sortie
du neurone du gradient en utilisant
* la valeur retournée par la méthode
@see getSortie
* @param ret represente la Retine
* @param posx représente l'abscisse du neurone
du Gradient
* @param posY représente l'ordonnée du
neurone du Gradient
*
*/
Ngrad(Retine ret, int posx,int posY) throws
IOException{
entree=new Neurone[3][3];
E=new int[3][3];
v=posx+0; w=posY+0;
entree[0][0]=ret.getNeuroneR(w,v);
v=posx+0; w=posY+1;
entree[0][1]=ret.getNeuroneR(w,v);
v=posx+0; w=posY+2;
entree[0][2]=ret.getNeuroneR(w,v);
v=posx+1; w=posY+0;
entree[1][0]=ret.getNeuroneR(w,v);
v=posx+1; w=posY+1;
entree[1][1]=ret.getNeuroneR(w,v);
v=posx+1; w=posY+2;
entree[1][2]=ret.getNeuroneR(w,v);
v=posx+2; w=posY+0;
entree[2][0]=ret.getNeuroneR(w,v);
v=posx+2; w=posY+1;
entree[2][1]=ret.getNeuroneR(w,v);
v=posx+2; w=posY+2;
entree[2][2]=ret.getNeuroneR(w,v);
|
for (int i=0;i<3;i++){
for (int j=0;j<3; ++){
E[i][j]=entree[i][j].sortie; }
}
i f ((E[0][0]+E[0][1]+E[0][2] ==3) &&
(E[1][0]
|
+ E[1][1]
|
+E[1][2]
|
+E[2][0] +E[2][1] +E[2][2] ==0))
|
sortN=10 ;
|
|
|
i f ((E[1][0]+E[1][1]+E[1][2]
|
==3) && (E[0][0]
|
+ E[0][1]
|
+E[0][2]
|
+E[2][0] +E[2][1] +E[2][2] ==0))
|
sortN=10 ;
|
|
|
i f ((E[2][0]+E[2][1]+E[2][2]
|
==3) && (E[0][0]
|
+ E[0][1]
|
+E[0][2]
|
+E[1][0] +E[1][1] +E[1][2] ==0))
|
sortN=10 ;
|
|
|
74
i f ((E[0][0]+E[1][0]+E[2][0] ==3) && (E[0][1] +
E[1][1]
+E[2][1] +E[0][2] +E[1][2] +E[2][2] ==0)) sortN=11
;
i f ((E[0][1]+E[1][1]+E[2][1] ==3) && (E[0][0] +
E[1][0]
+E[2][0] +E[0][2] +E[1][2] +E[2][2] ==0)) sortN=11 ;
i
f ((E[0][2]+E[1][2]+E[2][2] ==3) && (E[0][0] + E[1][0]
+E[2][0] +E[0][1] +E[1][1] +E[2][1] ==0)) sortN=11
;
i f ((E[2][1]+E[1][1]+E[1][2] ==3) && (E[0][0] +
E[1][0]
+E[2][0] +E[0][1] +E[0][2] +E[2][2] ==0)) sortN=1
;
i f ((E[1][0]+ E[1][1] +E[2][1] ==3) && (E[0][0]
+
E[2][0] +E[0][1] +E[0][2] +E[1][2] +E[2][2] ==0))
sortN=2 ;
i f ((E[1][0]+ E[1][1] +E[0][1] ==3) && (E[0][0]
+E[0][2]
+E[1][2] +E[2][0] +E[2][1] +E[2][2] ==0)) sortN=3
;
i f ((E[0][1] +E[1][1] +E[1][2] ==3) && (E[0][0]
+E[1][0]
+E[2][0] +E[2][1] +E[2][2] +E[0][2] ==0)) sortN=4
;
i f ((E[0][1] +E[1][1] +E[1][2] +E[2][1] ==4) &&
(E[0][0]
+E[1][0] +E[2][0] +E[2][2] +E[0][2] ==0)) sortN=5
;
i f ((E[1][0] +E[1][1] +E[1][2] +E[2][1] ==4) &&
(E[0][0]
+E[0][1] +E[0][2] +E[2][0] +E[2][2] ==0)) sortN=6
;
i f ((E[0][1] +E[1][1] +E[1][0] +E[2][1] ==4) &&
(E[0][0]
+E[0][2] +E[1][2] +E[2][2] +E[2][0] ==0)) sortN=7
;
i f ((E[0][1] +E[1][0] +E[1][1] +E[1][2] ==4) &&
(E[0][0]
+E[0][2] +E[2][0] +E[2][1] +E[2][2] ==0)) sortN=8
;
i f ((E[0][1] +E[1][1] +E[1][0] +E[1][2] +E[2][1] ==5)
&&
(E[0][0] +E[0][2] +E[2][0] +E[2][2] ==0)) sortN=9
;
this.sortie=sortN;
}
}
4.4.5. Implémentation de la couche
`'Gradient»
Ecrite en code Java, la couche du Gradient se
présente comme suit :
/**
*
* Classe du Gradient
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June,2012, 09:19
*
*/
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
public class Gradient{
Ngrad nG; //variable du neurone du Gradient
public static Ngrad[][] neuG;//variable de la matrice
des neurones du
Gradient
public Retine Ret;//variable de la couche
"rétine"
Neurone[][] nRet;//variable de la matrice des neurones
de la rétine
Ngrad[][] nsG;//variable de la matrice d'un certain
nombre de
neurones du Gradient
/**
* Constructeur de la classe Gradient
* La méthode crée d'abord une matrice de
291x291 neurones correspondant
* aux sorties des neurones de la Retine.
* Ensuite la méthode récupère les
sorties de 9 neurones de rétine pour chacun de ses neurones.
*
*/
Gradient() throws IOException{
Ret=new Retine();
neuG=new Ngrad[291][291];
Bu fferedImage img=new
Bu fferedImage(291,291,Bu
fferedImage.TYPE_INT_RGB);
75
WritableRaster trameG=img.getRaster();
int[] rgb2=new int[3];
int a ff=0;
}
}
or (int i=0;i<291;i++){
for (int j=0;j<291;j++){
neuG[j][i]=new Ngrad(Ret,j,i);
a ff=neuG[j][i].getSortie(neuG,j,i);
// System.out.print(a ff);
}
// System.out.println("");
or (int i=0;i<291;i++){
for (int j=0;'<291;j++){
a ff=neuG[j][i].getSortie(neuG,j,i);
i f (a ff==0){
rgb2[0]=255;rgb2[1]=255;rgb2[2]=255;
}else{
rgb2[0]=0;rgb2[1]=0;rgb2[2]=0;
}
trameG.setPixel(j,i,rgb2);
}
}
/**
* Méthode qui retourne un neurone se trouvant
à la position (posNG1,posNG2).
* @param posNG1 l'abscisse de la position du neurone
dans le Gradient
* @param posNG2 l'ordonnée de la position du
neurone dans le Gradient
* @return nG
*/
public Ngrad getNeuroneG(int posNG1,int
posNG2){
nG=neuG[posNG2][posNG1];
return nG;
}
/**
* Méthode qui retourne une matrice de neurones
nombreNG1 X nombreNG2.
* @param nombreNG1 le nombre de colonnes de la
matrice de neurones du Gradient
* @param nombreNG2 le nombre de lignes de la matrice de
neurones du Gradient
* @return nsG
*/
public Ngrad[][] getNeuronesG(int nombreNG1,int
nombreNG2){ nsG=new Ngrad [nombreNG2][nombreNG1]; for (int
i=0;i<nombreNG1;i++){
for (int j=0;j<nombreNG2;j++){
nsG[j][i]=neuG[j][i];
}
}
return nsG;
}
}
4.4.6. Implémentation de l'Aire de
sortie
Ecrite en langage Java, l'Aire de sortie se
présente de la manière suivante : /**
*
* Classe de l'Aire de sortie
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June,2012, 09:19
*
*/
import java.io.*;
public class AireSortie{
76
public Gradient grad; Ngrad [][] nG;
int M[][];
int lignes,colonnes,n,m; /**
* Constructeur de la classe AireSortie
* La méthode crée d'abord une matrice de
291x291 neurones correspondant
* aux sorties des neurones du Gradient.
* Ensuite la méthode récupère les
sorties de tous les neurones du Gradient.
* Après quoi, la méthode compte le
nombre de lignes et de colonnes du tableau
* avant de générer sa structure au
format HTML et au format MS
WORD.
*/
AireSortie() throws zOException{
lignes=0;colonnes=0;n=0;m=0;
grad=new Gradient();
M=new int[291][291];
or (int l=0;l<291;l++){
or (int p=0;p<291;p++){
M[l][p]=grad.getNeuroneG(p,l).sortie;
}
}
//Décompte du nombre de lignes du
tableau:
for (int l=0;l<291;l++){
}
for (int p=0;p<291;p++){
i f ((M[l][p]==7)II(M[l][p]==5)){ m=1;
p=291;
} else{m=0;
}
} lignes=lignes+m;
System.out.println("Nombre de lignes=
"+lignes);
//Décompte du nombre de colonnes du
tableau:
for (int l=0;l<291;l++){
for (int p=0;p<291;p++){
i f (M[p][l]==6) {n=1;
p=291;
}else{n=0;
}
} colonnes=colonnes+n;
}
System.out.println("Nombre de colonnes=
"+colonnes);
//Génération de la structure du tableau au
format HTML :
FileWriter fichier;
StringBuffer contenu=new StringBuffer("");
File nfichier;
nfichier=new File("
C:/Tableau.html");
contenu.append("<html> \n <head> <style
type=\"text/css\"> <!-- table
{border-width: 1px; border-color:black;} td
{border-width: 1px; border-
style:solid; border-color:black;} --> </style>
\n <title> STRUCTURE DU
TABLEAU</title>\n</head>
<body><center> <table border style=\"solid\"
cellspacing=\"0\">");
for (int i=0;i<lignes;i++){
contenu.append("<tr>");
for (int j=0;j<colonnes; ++){
contenu.append("<td><font
color=\"white\">_</font></td>");
}
} contenu.append("</tr>");
contenu.append("</table></center></body></html>");
fichier=new FileWriter(nfichier);
fichier.write(contenu.toString()); fichier.close();
//Génération de la structure du tableau au
format MS WORD : FileWriter fichier2;
StringBuffer contenu2=new StringBuffer("");
File n fichier2;
77
n fichier2=new File("
C:/Tableau.doc");
contenu2.append("<html> \n <head> <style
type=\"text/css\"> <!-- table {border-width: 1px; border-color:black;} td
{border-width: 1px; border-style:solid; border-color:black;} -->
</style> \n <title> STRUCTURE DU
TABLEAU</title>\n</head> <body><center> <table
border style=\"solid\" cellspacing=\"0\">");
for (int i=0;i<lisanes;i++){
contenu2.append( <tr>");
for (int j=0;j<colonnes;j++){
}
contenu2.append("</tr>");
contenu2.append("<td>< font
color=\"white\">_</font></td>");
}
contenu2.append("</table></center></body></html>");
fichier2=new FileWriter(n fichier2);
fichier2.write(contenu.toString()); fichier2.close();
}
}
4.4.7. Implémentation du Réseau (classe
principale)
Ecrite en code Java, la classe principale du
réseau se présente de la manière suivante :
/**
*
* Classe principale du Réseau
* @author BISIMWA MUGISHO Pacifique
* @version 1.1
* @since 1.0
* @created on 15th June,2012, 09:19
*
*/
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.Toolkit;
import java.io.*;
public class Reseau extends Frame{
Button quit = new Button("QUITTER LE
PROGRAMME");
Button dem = new Button("DEMARRER LE
PROGRAMME");
Button alp = new Button("AIDE SUR LE
PROGRAMME");
Aid pa12=new Aid();
Reseau(){
Label nord = new Label();Label nord1 = new
Label();
Panel sud = new Panel();
Label est = new Label();Label est1 = new
Label();
Label ouest = new Label();
Panel centre = new Panel();Panel centre1 = new
Panel();
setTitle("RECONNAISSANCE DES TABLEAUX");
setBackground(new Color(220,220,225));
setLayout(new BorderLayout());
add("North",nord);nord.setBackground(new
Color(210,210,255));
add("East",est);est.setBackground(new
Color(210,210,255));
add("Center",centre);centre.setBackground(new
Color(205,205,255));
add("West",ouest);ouest.setBackground(new
Color(210,210,255));
78
add("South",sud);sud.setBackground(new
Color(210,210,255));
FlowLayout fs_new FlowLayout(FlowLayout.CENTER);
sud.setLayout( fs);
sud.add(quit);quit.setBackground(new Color(100,200,230));
sud.add(dem);dem.setBackground(new Color(100,200,230));
sud.add(alp);alp.setBackground(new Color(100,200,230)); BorderLayout bes_new
BorderLayout();
centre.setLayout(bes);
centre.add("North",nord1); nord1.setBackground(new
Color(150,250,255));
centre.add("East",est1); est1.setBackground(new
Color(150,250,255));
centre.add("Center",centre1);
centre1.setBackground(new Color(150,250,255));
GridLayout gsoe_new GridLayout(16,1);
Label tit1 _ new Label(" BIENVENU
DANS NOTRE PROGRAMME
");
Label tit2 _ new Label("EXTRACTION DE LA STRUCTURE
D'UN TABLEAU PAR UN RESEAU DE NEURONES");
Label tit3 _ new
Label("_________________________________________________________________
");
Label tit4 _ new Label(" ");
Label tit5 _ new Label(" TRAVAIL PRESENTE ET SOUTENU POUR
L'OBTENTION DU DIPLOME DE LICENCE ");
Label tit6 _ new Label(" EN
PEDAGOGIE APPLIQUEE A L'I.S.P./Bukavu ");
Label tit7 _
new Label("
Département d'INFORMATIQUE DE GESTION
");
Label tit8 _ new Label("
Présenté par:");
Label tit9 _ new Label("
BISIMWA MUGISHO Pacifique");
Label tit10 _ new Label("
Travail dirigé par :");
Label tit11 _ new Label("
Professeur Blaise MWEPU FYAMA");
Label tit12 _ new Label(" ");
Label tit13 _ new
Label("____________________________________________________________");
Label tit14 _ new Label(" ");
Label tit15 _ new
Label("
Année académique 2011 - 2012
");
centre1.setLayout(gsoe);
centre1.add(tit1);tit1.setFont(new
Font("ArialBlack",Font.BOLD,20));tit1.setForeground(new
Color(100,200,230));
centre1.add(tit2);tit2.setFont(new
Font("ArialBlack",Font.BOLD,19));tit2.setForeground(Color.BLUE);
centre1.add(tit3);tit3.setFont(new
Font("ArialBlack",Font.BOLD,28));
centre1.add(tit4);tit4.setBackground(new
Color(100,200,220));
centre1.add(tit5);tit5.setFont(new
Font("Helvetica",Font.BOLD,18));tit5.setBackground(new
Color(230,230,255));
centre1.add(tit6);tit6.setFont(new
Font("Helvetica",Font.BOLD,18));tit6.setBackground(new
Color(230,230,255));
centre1.add(tit7);tit7.setFont(new
Font("Helvetica",Font.BOLD,18));tit7.setBackground(new
Color(230,230,255));
centre1.add(tit8);tit8.setFont(new
Font("Helvetica",Font.BOLD+Font.ITALIC,14));tit8.setBackground(new
Color(230,230,255));
centre1.add(tit9);tit9.setFont(new
Font("Helvetica",Font.BOLD,20));tit9.setBackground(new
Color(230,230,255)); centre1.add(tit10);tit10.setFont(new
Font("Helvetica",Font.BOLD+Font.ITALIC,14));tit10.setBackground(new
Color(230,230,255));
centre1.add(tit11);tit11.setFont(new
Font("Helvetica",Font.BOLD,20));tit11.setBackground(new
Color(230,230,255));
79
centrel.add(titl2);titl2.setBackground(new
Color(l00,200,220)); centrel.add(titl3);titl3.setFont(new
Font("ArialBlack",Font.BOLD,30));
centrel.add(titl4);
centrel.add(titl5);titl5.setFont(new
Font("ArialBlack",Font.BOLD+Font.ITALIC,l4));
this.setSize(800,550);
this.setvisible(true);
Dimension screen = Toolkit.getDe
faultToolkit().getScreenSize(); this.setLocation((screen.width -
this.getSize().width)/9,(screen.height -
this.getSize().height)/45);
/**
}
******************************************************************
********************************/
public boolean handleEvent(Event evtl){
/********************************************************************
***************/
i f(evtl.target instanceo f Button){
String strbAc=(String)evtl.arg;
if(strbAc==null)return false;
/********************************************************************
***************/
i f(strbAc.equals("QUITTER LE PROGRAMME")){
System.exit(l);
return true;
}
**********/
if(strbAc.equals("DEMARRER LE PROGRAMME")){
try {
//Détection et extraction de la structure du
tableau :
new AireSortie();
//Affichage de la structure du tableau :
Runtime.getRuntime().exec(new String[]{
"rundll32",
"url.dll,FileProtocolHandler", "
C:/Users/BMP/Desktop/TP2/Tableau.html"});
} catch (IOException e) {
e.printStackTrace();
}
// System.out.println("DEMARRER LE PROGRAMME");
return
true;
}
**********/
i f(strbAc.equals("AIDE SUR LE PROGRAMME")){
pal2.setvisible(true);
return true;
}
}
return true;
}
public static void main(String[]args)throws
IOException{
//Lancement du programme:
new Reseau();
}
}
Le code de la classe Aid se présente comme suit
:
import java.awt.*; import java.io.*;
@SuppressWarnings("serial")
class Aid extends Frame{
Button quit = new Button("retourner");
Aid(){
setTitle("GUIDE DE L'UTILISATEUR");
setBackground(Color.green);
Label nord = new Label();Label nordl = new
Label();
Panel sud = new Panel();
FlowLayout fs=new FlowLayout(FlowLayout.CENTER);
sud.setLayout( fs);
sud.add(quit);quit.setBackground(new Color(l00,l00,225));
Label est = new Label();Label estl = new Label(); Label ouest = new
Label();
Panel centre = new Panel();Panel centrel = new
Panel();
Label nord2 = new Label("
pacifiquemugisho@yahoo.fr
Tél: 099275830l");
Label sud2 = new Label();
Label est2 = new Label();
Label ouest2 = new Label();
TextArea centre2 = new
Textarea();centre2.setBackground(new
Color(200,225,225));
try{
InputStream ips=new FileInputStream("
C:/aidepro.txt");
InputStreamReader ipsr=new InputStreamReader(ips);
BufferedReader br=new BufferedReader(ipsr);
String ligne,chaine;chaine=new String();
while ((ligne=br.readLine())!=null){
System.out.println(ligne);
centre2.setText(chaine+=ligne+"\n");
80
}
br.close();
}catch(IOException
ioe){System.out.println();}
setLayout(new BorderLayout());
add("North",nord);nord.setBackground(new
Color(l50,250,255)); add("East",est);est.setBackground(new Color(l50,250,255));
add("Center",centre);centre.setBackground(new Color(l50,250,255));
add("west",ouest);ouest.setBackground(new
Color(l50,250,255)); add("South",sud);sud.setBackground(new
Color(l50,250,255)); BorderLayout bes=new BorderLayout();
centre.setLayout(bes);
centre.add("North",nordl); nordl.setBackground(new
Color(l50,250,255));
centre.add("East",estl); estl.setBackground(new
Color(l50,250,255));
centre.add("Center",centrel); centrel.setBackground(new
Color(l50,250,255));
BorderLayout besl=new BorderLayout();
centrel.setLayout(besl);
centrel.add("North",nord2);nord2.setBackground(new
Color(l50,250,255));
centrel.add("East",est2);est2.setBackground(new
Color(l50,250,255));
centrel.add("Center",centre2);
centrel.add("west",ouest2);ouest2.setBackground(new
Color(l50,250,255));
centrel.add("South",sud2);sud2.setBackground(new
Color(l50,250,255));
this.setSize(500,400);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation((screen.width -
this.getSize().width)/9,(screen.height -
this.getSize().height)/45);
}
/**************************************************************************
**************************/
public boolean handleEvent(Event evtl){
/********************************************************************
***************/
i f(evtl.target instanceo f Button){
String strbai=(String)evtl.arg;
if(strbAi==null)return false;
/********************************************************************
***************/
if(strbai.equals("retourner")){
// p.setvisible(true);
this.setvisible(false);
81
//System.exit(1);
//system.out.println("retourner");
return true;
}
}
return true;
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~/
}
| 
