Traitement d`images en Java

Traitement d'images en Java
par Mohamed Slim (slim_java)
Date de publication : 03 juillet 2010
Dernière mise à jour :
Cet article est destiné aux développeurs Java qui souhaitent écrire des applications
permettant de faire du traitement d'images en Java avec l'API Java 2D.
Pour comprendre les notions présentées dans cet article, une connaissance préalable de
l'API SWING est un minimum requis.

Traitement d'images en Java par Mohamed Slim (slim_java)
- 2 -
http://slim-boukettaya.developpez.com/tutoriels/traitement-images-java/
I - Introduction..............................................................................................................................................................3
I-A - Image numérique........................................................................................................................................... 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 - Fonctionnalités......................................................................................................................................5
II-B-2 - Architecture de l'API.............................................................................................................................5
III - Étude de cas.........................................................................................................................................................6
III-A - Présentation de l'application........................................................................................................................ 6
III-B - Architecture.................................................................................................................................................. 7
IV - Implémentation......................................................................................................................................................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 - Création d'images......................................................................................................................................12
IV-E - Traitement sur les images......................................................................................................................... 13
IV-E-1 - Réduire la taille de l'image............................................................................................................... 13
IV-E-2 - Récupérer 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 mathématique................................................................................................................15
IV-F - Enregistrement d'une image......................................................................................................................17
V - Liens utiles...........................................................................................................................................................18
VI - Conclusions.........................................................................................................................................................18
VII - Remerciements.................................................................................................................................................. 18

Traitement d'images en Java par Mohamed Slim (slim_java)
- 3 -
http://slim-boukettaya.developpez.com/tutoriels/traitement-images-java/
I - Introduction
I-A - Image numérique
Les images que vous affichez sur votre écran, que vous créez ou modifiéez avec votre logiciel de dessin comme
Photoshop ou Gimp, sont en fait stockées sur votre ordinateur sous forme binaire (suite de 0 et de 1). Elles sont
appelées de ce fait des images numériques.
Ces images sont divisées on deux types : les images matricielles et les images vectorielles.
I-A-1 - Image vectorielle
D'après Wikipédia, une image vectorielle (ou image en mode trait), en informatique, est une image numérique
composée d'objets géométriques individuels (segments de droite, polygones, arcs de cercle, etc.) définis chacun par
divers attributs de forme, de position, de couleur, etc.
Elle se différencie de cette manière des images matricielles (ou " bitmap "), dans lesquelles on travaille sur des pixels.
Ces images peuvent être créés avec des logiciels spécifiques 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 représentée, comme son nom l'indique, par une matrice de points (un tableau
à deux dimensions).Ces points sont appelés des pixels.
Le nom pixel provient du terme anglais PICture ELement qui signifie le plus petit élément de l'image qui peut être
manipulé par le matériel 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
coloriés à cause de l'effet aliasing (ou crénelage) qui apparaitront lors d'une faible résolution.
Chaque pixel (abrégé px) admet une couleur et est approximativement rectangulaire.
Les couleurs de l'image peuvent être codées suivant une palette, comme pour le format GIF, ou peuvent aussi être
codées dans l'espace de couleur RVB (ou RGB en anglais pour Red, Green, Blue) où chaque couleur est représentée
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 préférées.
Les axes de l'image sont orientés de la façon suivante :

Traitement d'images en Java par Mohamed Slim (slim_java)
- 4 -
http://slim-boukettaya.developpez.com/tutoriels/traitement-images-java/
Chaque pixel est repéré par ses coordonnées 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 numériques, vous pouvez consulter ce lien.
I-B - Traitement d'images
Le traitement d'images est l'ensemble des opérations qui entrainent la modification des images numériques.
Ces modifications portent généralement sur la couleur des pixels.
Plusieurs techniques sont utilisées pour manipuler ces données,
le but étant l'amélioration de ces données afin d'obtenir une plus grande lisibilité de l'image.
On trouve plusieurs logiciels gratuits ou payants spécifiques 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é conçu pour écrire des pages Web dynamiques intégrant des applets, chez le client, qui
communiquent avec des Servlets sur les serveurs.
Cette orientation vers le Web a changé grâce à la multitude des classes Java (3780 classes dans Java SE 6). On
peut trouver dès lors des applications de bureau ou d'autres destinées pour les PDA écrites en Java.
Java est présent aussi dans le domaine de l'infographie. C'est grâce à son API Java 2D qu'on peut écrire des
logiciels de traitement et d'analyse d'images performants comme imageJ qui est riche en fonctionnalités et
utilisable sur différents systèmes d'exploitation.

Traitement d'images en Java par Mohamed Slim (slim_java)
- 5 -
http://slim-boukettaya.developpez.com/tutoriels/traitement-images-java/
II-B - Java2D
II-B-1 - Fonctionnalités
Java 2D est une API composée par un ensemble de classes destinées à l'imagerie et à la création de dessin 2D.
Elle permet de :
• dessiner des lignes, des rectangles et toute autre forme géométrique ;
• replisser les formes par des couleurs unies ou en dégradés et lui ajouter des textures ;
• ajouter du texte, lui attribuer différentes polices et contrôler son rendu ;
• dessiner des images, éventuellement en effectuant des opérations de filtrage.
Dans cet article on va traiter la partie imagerie de l'API comme on va voir les différentes 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 :
Ajava.awt.Image :
c'est la super classe fournie dans la JDK depuis sa version 1.0. C'est une classe abstraite qui permet de
représenter les images sous forme d'un rectangle de pixels.
La restriction de cette classe est qu'elle ne permet pas d'accéder aux pixels. Elle est donc inadaptée pour le
traitement d'images.
Bjava.awt.image.BufferedImage :
Ajoutée à la JDK depuis sa version 2. Elle hérite de la classe Image et implémente ses interfaces pour permettre
d'examiner l'intérieur des images chargées et travailler directement sur ses données. On peut donc à partir d'un
objet BufferedImage, récupérer les couleurs des pixels et changer ces couleurs. Comme son nom l'indique,
BufferedImage est une image tampon. Cette classe gère l'image dans la mémoire et fournit des méthodes
pour l'interprétation 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 :