Trait em en Tim Age Java

Traitement d'images en Java
par Mohamed Slim (slim_java)

Date de publication : 03 juillet 2010 Dernire mise jour :
Cet article est destin aux dveloppeurs Java qui souhaitent crire des applications permettant de faire du traitement d'images en Java avec l'API Java 2D. Pour comprendre les notions prsentes dans cet article, une connaissance pralable de l'API SWING est un minimum requis.
Traitement d'images en Java par Mohamed Slim (slim_java)
I - Introduction..............................................................................................................................................................3 I-A - Image numrique........................................................................................................................................... 3 I-A-1 - Image vectorielle................................................................................................................................... 3 I-A-2 - Image matricielle................................................................................................................................... 3 I-B - Traitement d'images....................................................................................................................................... 4 II - Traitement d'images en Java.................................................................................................................................4 II-A - Introduction....................................................................................................................................................4 II-B - Java2D.......................................................................................................................................................... 5 II-B-1 - Fonctionnalits......................................................................................................................................5 II-B-2 - Architecture de l'API.............................................................................................................................5 III - tude de cas.........................................................................................................................................................6 III-A - Prsentation de l'application........................................................................................................................ 6 III-B - Architecture.................................................................................................................................................. 7 IV - Implmentation......................................................................................................................................................8 IV-A - Construction des menus..............................................................................................................................8 IV-B - Lecture d'un fichier image en local........................................................................................................... 10 IV-C - Affichage des images................................................................................................................................ 11 IV-D - Cration d'images......................................................................................................................................12 IV-E - Traitement sur les images......................................................................................................................... 13 IV-E-1 - Rduire la taille de l'image............................................................................................................... 13 IV-E-2 - Rcuprer les pixels de l'image........................................................................................................14 IV-E-3 - Modifier la couleur des pixels de l'image..........................................................................................14 IV-E-4 - Binarisation de l'image...................................................................................................................... 15 IV-E-5 - Convolution mathmatique................................................................................................................15 IV-F - Enregistrement d'une image...................................................................................................................... 17 V - Liens utiles...........................................................................................................................................................18 VI - Conclusions.........................................................................................................................................................18 VII - Remerciements.................................................................................................................................................. 18
http://slim-boukettaya.developpez.com/tutoriels/traitement-images-java/
-2-
I - Introduction I-A - Image numrique

Les images que vous affichez sur votre cran, que vous crez ou modifiez avec votre logiciel de dessin comme Photoshop ou Gimp, sont en fait stockes sur votre ordinateur sous forme binaire (suite de 0 et de 1). Elles sont appeles de ce fait des images numriques. Ces images sont divises on deux types : les images matricielles et les images vectorielles.
I-A-1 - Image vectorielle

D'aprs Wikipdia, une image vectorielle (ou image en mode trait), en informatique, est une image numrique compose d'objets gomtriques individuels (segments de droite, polygones, arcs de cercle, etc.) dfinis chacun par divers attributs de forme, de position, de couleur, etc. Elle se diffrencie de cette manire des images matricielles (ou " bitmap "), dans lesquelles on travaille sur des pixels. Ces images peuvent tre crs avec des logiciels spcifiques comme Adope Flash ou Adope Illustrator. Il existe de nombreux formats de fichiers vectoriels, parmi lesquels, on peut citer : .SVG, .DXF ou .DWG.
I-A-2 - Image matricielle

Une image matricielle ou bitmap est reprsente, comme son nom l'indique, par une matrice de points (un tableau deux dimensions).Ces points sont appels des pixels. Le nom pixel provient du terme anglais PICture ELement qui signifie le plus petit lment de l'image qui peut tre manipul par le matriel et les logiciels d'imageries ou d'impression. En fait, vos fichiers d'extension .bmp, .jpg, .gif, .png sont des fichiers d'images bitmap. Lorsque vous zoomez une image bitmap comme le montre la figure ci-dessous, vous pouvez identifier ces points coloris cause de l'effet aliasing (ou crnelage) qui apparaitront lors d'une faible rsolution.
Chaque pixel (abrg px) admet une couleur et est approximativement rectangulaire. Les couleurs de l'image peuvent tre codes suivant une palette, comme pour le format GIF, ou peuvent aussi tre codes dans l'espace de couleur RVB (ou RGB en anglais pour Red, Green, Blue) o chaque couleur est reprsente par trois couleurs fondamentales Rouge (Red) Vert (Green) et Bleu (Blue). Vous pouvez consulter cette page pour obtenir le codage sur trois octets de vos couleurs prfres. Les axes de l'image sont orients de la faon suivante :
-3-
Chaque pixel est repr par ses coordonnes x et y. Avant d'enregistrer une image, il faut lui attribuer un format de stockage comme le format .jpg ou .bmp. Chaque format utilise un algorithme de compression qui peut tre avec perte ou sans perte. Parmi ces algorithmes, on peut citer LZW, RLE, etc. Pour plus d'information sur les images numriques, vous pouvez consulter ce lien.
I-B - Traitement d'images

Le traitement d'images est l'ensemble des oprations qui entrainent la modification des images numriques. Ces modifications portent gnralement sur la couleur des pixels. Plusieurs techniques sont utilises pour manipuler ces donnes, le but tant l'amlioration de ces donnes afin d'obtenir une plus grande lisibilit de l'image. On trouve plusieurs logiciels gratuits ou payants spcifiques pour le traitement des images matricielles ou vectorielles. On peut citer Adope Photoshop pour le traitement des images bitmap.
II - Traitement d'images en Java II-A - Introduction

Java est un langage de programmation multiplateforme connu par la richesse de ses API et par sa portabilit. la base, Java t conu pour crire des pages Web dynamiques intgrant des applets, chez le client, qui communiquent avec des Servlets sur les serveurs. Cette orientation vers le Web a chang grce la multitude des classes Java (3780 classes dans Java SE 6). On peut trouver ds lors des applications de bureau ou d'autres destines pour les PDA crites en Java. Java est prsent aussi dans le domaine de l'infographie. C'est grce son API logiciels de traitement et d'analyse d'images performants comme utilisable sur diffrents systmes d'exploitation. Java 2D qu'on peut crire des imageJ qui est riche en fonctionnalits et
-4-
II-B - Java2D II-B-1 - Fonctionnalits

Java 2D est une API compose par un ensemble de classes destines l'imagerie et la cration de dessin 2D. Elle permet de : dessiner des lignes, des rectangles et toute autre forme gomtrique ; replisser les formes par des couleurs unies ou en dgrads et lui ajouter des textures ; ajouter du texte, lui attribuer diffrentes polices et contrler son rendu ; dessiner des images, ventuellement en effectuant des oprations de filtrage.
Dans cet article on va traiter la partie imagerie de l'API comme on va voir les diffrentes fonctions fournies pour faire le traitement d'images.
II-B-2 - Architecture de l'API

Pour travailler avec les images sous Java 2D, il faut connaitre deux classes importantes de l'API :
java.awt.Image : c'est la super classe fournie dans la JDK depuis sa version 1.0. C'est une classe abstraite qui permet de reprsenter les images sous forme d'un rectangle de pixels. La restriction de cette classe est qu'elle ne permet pas d'accder aux pixels. Elle est donc inadapte pour le traitement d'images. java.awt.image.BufferedImage : Ajoute la JDK depuis sa version 2. Elle hrite de la classe Image et implmente ses interfaces pour permettre d'examiner l'intrieur des images charges et travailler directement sur ses donnes. On peut donc partir d'un objet BufferedImage, rcuprer les couleurs des pixels et changer ces couleurs. Comme son nom l'indique, BufferedImage est une image tampon. Cette classe gre l'image dans la mmoire et fournit des mthodes pour l'interprtation des pixels. Si on veut faire du traitement d'images, il faut donc travailler avec des objets BufferedImage. Comme le montre la figure suivante, un objet BufferedImage est compos de deux parties :
-5-
java.awt.image.ColorModel: cette classe dfinit la faon d'interprter les couleurs. Le ColorModel est capable de traduire les valeurs des donnes provenant du Raster en objet java.awt.Color. java.awt.image.Raster : elle contient les donnes de l'image et peut les reprsenter comme un tableau de valeurs de pixels. Aussi, elle maintient les donnes de l'image dans la mmoire et fournit des mthodes pour accder des pixels spcifiques au sein de l'image. Modifier les donnes d'une image est en crer d'autres instances.
Pour plus d'informations sur l'API Java2D, vous pouvez consulter ce lien http://java.sun.com/j2se/1.4.2/docs/ guide/2d/spec.html.
III - tude de cas III-A - Prsentation de l'application

Cette application est un logiciel crit en Java permettant d'appliquer certaines oprations sur les images bitmap. Elle permet de : lire des fichiers images et les afficher sur l'cran ; enregistrer des images aprs modification sur le disque ; appliquer un ensemble de filtres comme : rendre l'image en niveau de gris ou binarisation de l'image , assombrir les couleurs des pixels , ajouter un effet de brillance. Appliquer certain filtres linaires , zoomer / dzoomer l'image.
-6-
J'ai crit cette application spcialement pour cet article, donc vous pouvez tlcharger le code et l'amliorer suivant vos besoins. L'application supporte seulement le format .jpg, vous devez donc modifier le code pour pouvoir grer d'autres formats. Pour comprendre les codes prsents dans la partie qui suit, une connaissance de l'API SWING est ncessaire notamment la partie programmation par dlgation et la gestion des vnements.
III-B - Architecture
L'application est compose de deux classes : Classe Cadre : cette classe reprsente la fentre principale de l'application. Le constructeur de cette classe permet de crer trois menus : le menu Fichier contient un sous-menu Ouvrir qui permet d'ouvrir un fichier image stock sur le disque et un deuxime sous menu Enregistrer qui permet d'enregistrer une image sur le disque aprs modification ; le menu Filtre contient cinq sous menus qui prsentent les principaux traitements applicables sur les images charges depuis le disque ; le menu Retailler quant lui, contient le sous menu Zoomer et Dzoomer permettant respectivement comme le nom de chacun l'indique d'agrandir ou de rduire la taille de l'image charge.
Classe PanDessin : Cette classe drive de JPanel. Elle prsente le panneau o seront affiches les images charges par l'application. Elle admet un attribut unique monImage de type BufferedImage qui prsente tout moment l'image charge affiche dans le panneau. Cette classe prsente le cur de l'application. Ses mthodes permettent de modifier les images.
BufferedImage monImage = null; protected } protected } protected } protected void reduireImage(){ void agrandirImage(){ void imageConvolue(){ void imageEclaircie(){ -7-
Traitement d'images en Java par Mohamed Slim (slim_java) } protected } protected } protected } protected } protected } protected } protected }
void imageSombre(){ void imageBinaire(){ void imageEnNiveauGris(){ void modifierImage(){ void ajouterImage(File fichierImage){ BufferedImage getImagePanneau(){ void enregistrerImage(File fichierImage){
IV - Implmentation IV-A - Construction des menus

Les oprations de traitement sont dclenches suite aux appuis sur la commande correspondante dans la barre de menus. Par exemple si vous voulez ouvrir une image comme une opration de dbut, il faut slectionner le menu Fichier et cliquer ensuite sur le sous-menu Ouvrir et de la mme faon pour les autres oprations. La cration du menu doit se faire dans le constructeur de la classe Cadre :
public Cadre() { setJMenuBar(menuBar); menuBar.add(fichierMenu); fichierMenu.setText("Fichier"); fichierMenu.add(ouvrirMenu); ouvrirMenu.addActionListener((ActionListener)this); ouvrirMenu.setText("ouvrir"); fichierMenu.add(enregistrerMenu); enregistrerMenu.addActionListener((ActionListener)this); enregistrerMenu.setText("enregistrer"); menuBar.add(filtreMenu); filtreMenu.setText("Filtre"); filtreMenu.add(niveauGrisMenu); niveauGrisMenu.addActionListener((ActionListener)this); niveauGrisMenu.setText("niveau de gris"); filtreMenu.add(binarisationMenu); binarisationMenu.addActionListener((ActionListener)this); binarisationMenu.setText("binarisation"); filtreMenu.add(assombrirMenu); assombrirMenu.addActionListener((ActionListener)this); assombrirMenu.setText("assombrir"); filtreMenu.add(brillanceMenu); brillanceMenu.addActionListener((ActionListener)this); brillanceMenu.setText("brillance"); filtreMenu.add(convolutionMenu); convolutionMenu.addActionListener((ActionListener)this); convolutionMenu.setText("convolution"); menuBar.add(retaillerMenu); retaillerMenu.setText("retailler"); retaillerMenu.add(agrandirMenu); -8-
Traitement d'images en Java par Mohamed Slim (slim_java) agrandirMenu.addActionListener((ActionListener)this); agrandirMenu.setText("agrandir"); retaillerMenu.add(reduireMenu); reduireMenu.addActionListener((ActionListener)this); reduireMenu.setText("reduire"); // ajouter le panneau de dessin getContentPane().add(panneau);
La dernire instruction du constructeur permet d'associer un objet de la classe PanDessin l'objet Cadre, ce qui permet d'ajouter un panneau notre fentre. Ce panneau sera ensuite la zone d'affichage des images. Selon le principe de programmation par dlgation, un appui sur l'un des sous-menus, fait appel la mthode actionPerformed() :
public void actionPerformed(ActionEvent )
Selon le sous-menu slectionn, cette mthode fait appel la mthode correspondante dans la classe PanDessin.
public void actionPerformed(ActionEvent cliqueMenu) { if (cliqueMenu.getSource().equals(ouvrirMenu)) { // ouvrir une image [...] panneau.ajouterImage(..chemin du fichier image..) ; } } else if (cliqueMenu.getSource().equals(enregistrerMenu)) { // enregistrer une image [...] panneau.enregistrerImage(fichierEnregistrement); } } else if (cliqueMenu.getSource().equals(niveauGrisMenu)) { // Changer l'image en niveau de gris panneau.imageEnNiveauGris(); } else if (cliqueMenu.getSource().equals(brillanceMenu)) { // Eclaircir l'image panneau.imageEclaircie(); } else if(cliqueMenu.getSource().equals(assombrirMenu)) { // Rendre l'image plus sombre panneau.imageSombre(); } else if (cliqueMenu.getSource().equals(binarisationMenu)) { // Rendre l'image binaire panneau.imageBinaire(); } else if (cliqueMenu.getSource().equals(convolutionMenu)) { // Faire la convolution mathmatique suivant un masque donn panneau.imageConvolue(); } else if (cliqueMenu.getSource().equals(agrandirMenu)) { // Agrandir l'image panneau.agrandirImage(); } -9-
Traitement d'images en Java par Mohamed Slim (slim_java) else if (cliqueMenu.getSource().equals(reduireMenu)) { //reduire la taille de l'image panneau.reduireImage(); } }
IV-B - Lecture d'un fichier image en local

La mthode ajouterImage() de la classe PanDessin permet de lire un fichier image. Elle prend en paramtre un objet de type java.io.File qui correspond au fichier image :
protected void ajouterImage(File fichierImage) { // lire l'image monImage = ImageIO.read(fichierImage); // Appel repaint pour activer l'affichage du panneau et visualisation // de l'image sur la surface du panneau. repaint(); }
L'objet fhcierImage est un objet de la classe java.io.File. On peut obtenir cet objet grce au constructeur de la classe File qui prend en paramtre le chemin du fichier.
File fichierImage = new File("C:\\duke.jpg"));
La mthode statique read() de la classe ImageIO permet de charger une image en mmoire depuis ce fichier en lui associant un objet BufferedImage. Cette mthode attend que l'image soit entirement charge avant de retourner l'objet BufferedImage. ImageIO est une classe du paquetage javax.imageio. Ce paquetage contient les classes de base et les interfaces pour la gestion des fichiers images. On trouve les classes suivantes : ImageIO : pour dcrire le contenu des fichiers images y compris les mtadonnes ; ImageReader, ImageReadParam et ImageTypeSpecifier : pour contrler le processus de lecture d'image. ImageWriter et ImageWriteParam : pour contrler le processus d'criture des images ; ImageTranscoder : pour faire le transcodage entre les formats ; IIOException : pour signaler les erreurs.
Les formats .jpg ou .gif sont des formats externes utiliss pour reprsenter des images numriques. Pour utiliser ces images en Java, il faut convertir ces formats en un format interne. Comme on a vu plus haut, cette conversion est faite par les classes du paquetage javax.imageio notamment la classe ImageReader et ImageTranscoder. En fait, les formats supports sont GIF, PNG, JPEG, BMP, WBMP. FORMAT JPEG PNG BMP WBMP GIF LU oui oui oui oui oui ECRIT oui oui oui oui non
La classe ImageIO choisit un lecteur appropri, en fonction du type de fichier. Dans ce but, elle peut consulter l'extension de fichier et le "numro magique" qui se trouve dans les premiers octets, et qui identifie le format du fichier.
- 10 -
Lorsqu'un lecteur adapt ne peut tre trouv ou si le lecteur ne parvient pas dcoder le contenu du fichier, la mthode read() renvoie null. D'autres formats comme le format TIFF peuvent tre traits par l'installation de fichiers JAR contenant des plug-ins qui une fois installs, permettront qu'un nouveau format sera automatiquement compris, sans aucune modification du code de l'application. Chaque format d'image son avantage et son inconvnient : Format GIF Avantages Supporte les animations et gre les pixels transparents. Compression sans perte. Supportent les images en couleurs relles (codes sur 24 bits) Idal pour les images photographiques Inconvnients Ne pend en charge que 256 couleurs Ne supporte pas d'animation
PNG
JPG
Compression avec perte. N'est pas bon pour les images contenant du texte et toute autre image o les donnes sont critiques.
On peut utiliser la mthode getReaderFormatNames() pour connaitre les formats supports en lecture :
String names[] = ImageIO.getReaderFormatNames(); for (int i = 0; i < names.length; ++i) { System.out.println(" fomat supporte en lecture :" + names[i]); }
Ce code retourne uniquement les formats supports en standard et aucun des plug-ins supplmentaires ne sera mentionn.
IV-C - Affichage des images

Aprs avoir lu le fichier de l'image avec la mthode read() et obtenu un objet BufferedImage pour la reprsenter en mmoire, elle peut tre maintenant affiche dans notre panneau. La mthode paintComponent() du panneau est spcialise dans l'affichage des lments graphiques qui se trouve dans la surface du panneau. Cette mthode est automatiquement sollicite ds que nous avons besoin d'afficher ou de rafficher la fentre de l'application. Nous devons donc passer par cette mthode pour tre sr que notre image soit raffiche au moment du rafrachissement.
protected void paintComponent(Graphics g) { super.paintComponent(g); if(monImage != null) g.drawImage(monImage, 0, 0, null); } - 11 -
Pour afficher notre image, il faut utiliser la mthode :

drawImage(Image img, int x, int y, ImageObserver observer)
de la classe java.awt.Graphics. le premier paramtre de la mthode doit tre de type Image ou un type driv. Dans notre cas, l'objet monImage est de type BufferedImage, elle fait rfrence l'image en mmoire. x et y : prsentent les coordonnes du point haut gauche de l'image.
observer : utilise pour mettre jour l'affichage de l'image lors d'un tlchargement d'une faon asynchrone. Ce paramtre n'est pas utilis lorsque l'on travaille avec des BufferedImage qui utilisent le mode de chargement synchrone. Il peut tre null.
Lors du chargement de l'image, vous pouvez lui imposer une taille, par exemple vous pouvez l'ajuster la surface du panneau.
g.drawImage(monImage, 0, 0,mon_panneau.getWtith(),mon_panneau.getHeight(), null);
IV-D - Cration d'images

Une image peut tre dessine dans la surface d'un panneau, comme elle peut tre elle aussi, une surface pour dessiner des formes 2D ou mme des images. On peut dessiner des formes gomtriques comme des cercles, des polygones dans une image en utilisant les mthodes de dessin fournies par Java 2D comme fillOval() ou fillPolygon() :
BufferedImage image = new BufferedImage(width_image, height_image, BufferedImage.TYPE_INT_RGB); // on rcupre le contexte graphique de la BufferedImage Graphics2D g = image.createGraphics(); // la couleur de dessin est le bleu g.setColor( Color.blue ); // on dessine un cercle rempli de rayon 200 dont le centre est de coordonnes (30,30) int Rayon = 200 ; g.fillOval( 50, 50, Rayon, Rayon ); // on libre la mmoire utilise pour le contexte graphique g.dispose();
- 12 -
la premire instruction permet de crer une image vide. On spcifie ses dimensions et sont type. Le type utilis pour cette image est BufferedImage.TYPE_INT_RGB. Les pixels d'une image de ce type sont spcifis par un entier dcrivant les valeurs de rouge, de vert et de bleu sans prendre en considration la couche alpha. Les types d'images indiquent comment les couleurs des pixels sont cods. Vous trouvez une liste des diffrents types pris en charge par la classe BufferedImage ici.
IV-E - Traitement sur les images IV-E-1 - Rduire la taille de l'image

En utilisant le menu Retailler on peut rduire ou agrandir la taille de l'image.
Il faut donc faire une transformation affine l'image.

protected void reduireImage() { // crer une nouvelle image qui contient les mmes donnes de l'image source mais ayant // une taille rduite par 2. BufferedImage imageReduite = new BufferedImage((int)(monImage.getWidth()*0.5),(int) ( monImage.getHeight()*0.5), monImage.getType()); // Une transformation affine effectue un changement d'chelle sur l'image. // On doit spcifier le rapport suivant les axes x et y. // la valeur 0.5 prsente le coefficient de multiplication. AffineTransform reduire = AffineTransform.getScaleInstance(0.5, 0.5); // // // // AffineTransformOp effectue une transformation gomtrique d'une image source pour produire une image destination. Il faut donc faire une interpolation des pixels pour construire l'image cible. L'entier AffineTransformOp.TYPE_BICUBIC prsente un compromis entre le temps de calcul et les performances.
int interpolation = AffineTransformOp.TYPE_BICUBIC; AffineTransformOp retaillerImage = new AffineTransformOp(reduire, interpolation); retaillerImage.filter(monImage, imageReduite ); monImage = imageReduite ; // Appel repaint pour activer l'affichage du panneau et visualisation // de l'image sur le panneau aprs changement repaint();
- 13 -
IV-E-2 - Rcuprer les pixels de l'image

Comme indiqu au dbut de l'article, un objet BufferedImage permet de manipuler les pixels de l'image. Le tableau de pixels de l'image est matrialis par un objet de type java.awt.image.Raster. En utilisant un objet instance de cette classe, on peut rcuprer les informations sur la couleur des pixels.
Raster tramePixel = monImage.getRaster(); int[] couleurRGB = new int[3]; System.out.println("teinte rouge = "+couleurRGB[0]); System.out.println("teinte verte = "+couleurRGB[1]); System.out.println("teinte bleu = "+couleurRGB[2]);
La couleur du pixel renvoye est stocke dans le tableau couleurRGB de taille 3. La premire case contient la valeur de la composante rouge, la deuxime pour la composante verte et la dernire case pour la teinte bleu. Dans notre cas, on a une connaissance pralable du type d'image qui est de type BufferedImage.TYPE_INT_RGB , c'est--dire que le modle de couleur est RGB sans transparence. Que fait-on alors si on ne connait pas le type de l'image et le modle de couleur utilis ? C'est ici qu'intervient la classe ColorModel qui est une composante de la classe BuferedImage et qui permet de reprsenter le modle de couleur utilis pour chaque image. Ainsi, une manire de faire est d'utiliser la mthode getDataElements() qui retourne la couleur du pixel sans vous charger de spcifier le modle de couleur utilis. Une nouvelle version du code prcdent devient :
Raster tramePixel = monImage.getRaster(); ColorModel modeleCouleur = monImage.getColorModel(); Object objCouleur = tramePixel.getDataElements(x, y, null); System.out.println("teinte rouge = "+ modeleCouleur.getRed(objCouleur)); System.out.println("teinte verte = "+ modeleCouleur .getGreen(objCouleur)) ; System.out.println("teinte bleu = "+ modeleCouleur.getBlue(objCouleur));
IV-E-3 - Modifier la couleur des pixels de l'image

Cependant, si on veut changer les couleurs de pixels, cette fois-ci il faut utiliser un objet de type WritableRaster. Comme son nom l'indique, cette classe tend la classe Raster : +--java.awt.image.Raster +--java.awt.image.WritableRaster Une manire de faire est d'utiliser cette fois ci la mthode setDataElements() la place de la mthode getDataElements() pour la modification des pixels.
int xPixel = 100 ; int yPixel = 100 ; WritableRaster trameModifiable = monImage.getRaster(); ColorModel modleCouleur = monImage.getColorModel(); int rgb = Color.white.getRGB(); Object couleurBlanc = modleCouleur.getDataElements(rgb, null); // la pixel qui se trouve la position (100,100) va prendre la couleur blanche trameModifiable.setDataElements(xPixel, yPixel, couleurBlanc);
- 14 -
IV-E-4 - Binarisation de l'image

Une image binaire est compose de pixels ayant uniquement l'une des deux couleurs noir ou blanc. Thoriquement, Il y a plusieurs mthodes pour rendre une image binaire.
Si on travaille avec la mthode de seuillage simple, la valeur de chaque pixel P(x, y) est compare un seuil S et si cette valeur est suprieure S, le pixel prend la valeur 1 (noir), sinon il prend la valeur 0 (blanc). En travaillant avec des BufferedImage, on peut rendre une image binaire on utilisant tout simplement le type BufferedImage.TYPE_BYTE_BINARY.
protected void imageBinaire() { BufferedImage imgBinaire = new BufferedImage(monImage.getWidth(), monImage.getHeight(), BufferedImage.TYPE_BYTE_BINARY); Graphics2D surfaceImg = imgBinaire.createGraphics(); surfaceImg.drawImage(monImage, null, null); monImage = imgBinaire; // Appel repaint pour activer l'affichage du panneau et visualisation // de l'image sur le panneau aprs changement repaint();
Par contre, vous pouvez utiliser la mthode de seuillage. En effet, si vous aviez fait ce choix, vous auriez d faire rfrence au code permettant de modifier la couleur des pixels prsent en haut. Toutefois, avant de faire la binarisation de l'image, il faut l'avoir modifie en niveau de gris en utilisant le type BufferedImage.TYPE_BYTE_GRAY pour avoir une seule composante de couleur.
IV-E-5 - Convolution mathmatique

Thoriquement, la convolution est le fait d'utiliser une matrice d'entiers appele aussi masque ou noyau, pour multiplier les valeurs de couleur d'un pixel donn de l'image par ce masque. Le principe de l'algorithme consiste amplifier la valeur d'un pixel P et de chacun des n pixels qui l'entourent par la valeur correspondante dans le noyau. Le but est d'additionner l'ensemble des rsultats pour que le pixel P prenne la valeur du rsultat final. Je ne suis pas un spcialiste en la matire mais vous pouvez consulter cet article pour plus de dtails sur le sujet. Le masque qu'on va utiliser est de taille 3x3.
float[ { 0.1f, 0.1f, 0.1f, }; ] masqueFlou = 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f
Il permet de rendre l'image floue comme le montre la figure suivante :

- 15 -
La mthode utilise pour ce filtre est imageConvolue() :

protected void imageConvolue() { BufferedImage imageFlou = new BufferedImage(monImage.getWidth(),monImage.getHeight(), monImage.getType()); float[ ] masqueFlou = { 0.1f, 0.1f, 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f }; Kernel masque = new Kernel(3, 3, masqueFlou); ConvolveOp opration = new ConvolveOp(masque); opration.filter(monImage, imageFlou); monImage = imageFlou; // Appel repaint pour activer l'affichage du panneau et visualisation // de l'image sur le panneau aprs changement } repaint();
L'opration de multiplication ou plus prcisment la convolution mathmatique est ralise par un objet de la classe ConvolveOp. Si vous voulez appliquer d'autres oprations comme la segmentation, l'estompage ou le gradient, vous devez tout simplement modifier les coefficients de la matrice de convolution dfinis par la variable
float[ ] masqueFlou
float[ ] masqueGradientX = { -1f, 0f, 1f , -2f, 0f, 2f , -1f, 0f, 1f }; - 16 -
Traitement d'images en Java par Mohamed Slim (slim_java) float[ ] masqueGradientY = { 1f, 2f, 1f, 0f, 0f, 0f, -1f, -2f, -1f };
Par exemple pour obtenir le gradient de Sobel, vous pouvez utiliser le masque ci-dessus :
IV-F - Enregistrement d'une image

Finalement, notre image source dfinie par un objet BufferedImage qu'on a obtenu dj a partir d'un fichier sur le disque, a subi diffrentes transformations. On peut donc conclure que les donnes de l'image source sont modifies et que son tableau de pixels (trame) stock dans la mmoire a chang de valeurs. On obtient alors une image affiche sur la surface du panneau diffrente de l'image initialement charge. Il faut donc penser enregistrer cette nouvelle image localise dans la mmoire sur le disque. Une manire de le faire consiste crer une image partir de la surface du panneau (objet de PanDessin) et enregistrer cette image dans un format donn. Pour crer cette image, on utilise la mthode getImagePanneau() :
protected BufferedImage getImagePanneau() { // rcuprer une image du panneau int width = this.getWidth(); int height = this.getHeight(); BufferedImage image = new BufferedImage(width, height, Graphics2D g = image.createGraphics(); this.paintAll(g); g.dispose(); return image; }
BufferedImage.TYPE_INT_RGB);
Par la suite, on fait appel la mthode enregistrerImage() qui permet d'crire cette image sur le disque en utilisant la mthode statique write() de la classe ImageIO.
protected void enregistrerImage(File fichierImage) { String format ="JPG"; BufferedImage image = getImagePanneau(); ImageIO.write(image, format, fichierImage); }
Comme pour la lecture des fichiers images, il faut connaitre les formats supports en criture par la classe ImageIO. Pour rcuprer ces formats on peut utiliser la mthode getWriterFormatNames() :
String[] names = ImageIO.getWriterFormatNames(); for (int i = 0; i < names.length; ++i) { System.out.println ("format supporte en ecriture : " + names[i]); }
Cette mthode retourne uniquement les formats supports en standard et aucun des plug-ins supplmentaires ne sera mentionn. Avec ce dernier paragraphe, qui traite l'enregistrement d'image en Java 2D, on arrive la fin de la prsentation de l'application travers laquelle j'ai essay d'exploiter les fonctionnalits de l'API Java 2D fournis pour le traitement d'images. D'autres mthodes dans le code de l'application n'ont pas t mentionnes vu qu'il s'agit des mmes traitements expliqus plus haut avec une lmentaire modification dans le code.
- 17 -
V - Liens utiles
Documentation de l'API Ecrire des plug-in pour de nouveau formats Guide de l'API java 2D Partie Image de la FAQ GUI Partie listener de la FAQ GUI
VI - Conclusions
Dans cet article, j'ai prsent diffrentes fonctionnalits de l'API Java 2D pour le traitement d'images. J'ai expliqu le code d'une application fentre qui permet de faire plusieurs oprations sur les images bitmap comme la lecture, l'enregistrement, l'application de filtres et le dimensionnement. Pour terminer, il faut dire que le traitement d'images en Java n'est pas limit aux services de l'API Java 2D, mais les dpassent pour utiliser l'API Java Advanced Image ou couramment JAI, qui tend les services offerts par Java 2D tout en tant compatible avec celle-ci.
VII - Remerciements
Je tiens remercier la rubrique Java de Developpez.com et son responsable Ricky81. Je remercie aussi Jacques THERY pour la relecture orthographique de l'article.
- 18 -

Trait em en Tim Age Java

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Trait em en Tim Age Java

Transféré par

Droits d'auteur :

Formats disponibles

Traitement d'images en Java

par Mohamed Slim (slim_java)

Traitement d'images en Java par Mohamed Slim (slim_java)

Traitement d'images en Java par Mohamed Slim (slim_java)

I - Introduction I-A - Image numrique

I-A-1 - Image vectorielle

I-A-2 - Image matricielle

Traitement d'images en Java par Mohamed Slim (slim_java)

I-B - Traitement d'images

II - Traitement d'images en Java II-A - Introduction

Traitement d'images en Java par Mohamed Slim (slim_java)

II-B - Java2D II-B-1 - Fonctionnalits

II-B-2 - Architecture de l'API

Traitement d'images en Java par Mohamed Slim (slim_java)

III - tude de cas III-A - Prsentation de l'application

Traitement d'images en Java par Mohamed Slim (slim_java)

IV - Implmentation IV-A - Construction des menus

IV-B - Lecture d'un fichier image en local

Traitement d'images en Java par Mohamed Slim (slim_java)

IV-C - Affichage des images

Traitement d'images en Java par Mohamed Slim (slim_java)

Pour afficher notre image, il faut utiliser la mthode :

IV-D - Cration d'images

Traitement d'images en Java par Mohamed Slim (slim_java)

IV-E - Traitement sur les images IV-E-1 - Rduire la taille de l'image

Il faut donc faire une transformation affine l'image.

Traitement d'images en Java par Mohamed Slim (slim_java)

IV-E-2 - Rcuprer les pixels de l'image

IV-E-3 - Modifier la couleur des pixels de l'image

Traitement d'images en Java par Mohamed Slim (slim_java)

IV-E-4 - Binarisation de l'image

IV-E-5 - Convolution mathmatique

Il permet de rendre l'image floue comme le montre la figure suivante :

Traitement d'images en Java par Mohamed Slim (slim_java)

La mthode utilise pour ce filtre est imageConvolue() :

float[ ] masqueGradientX = { -1f, 0f, 1f , -2f, 0f, 2f , -1f, 0f, 1f }; - 16 -

IV-F - Enregistrement d'une image

Traitement d'images en Java par Mohamed Slim (slim_java)

Vous aimerez peut-être aussi