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▲

I-A-2. Image matricielle ▲

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.

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.

II-B-1. Fonctionnalités▲

II-B-2. Architecture de l'API ▲

Cette application est un logiciel écrit en Java permettant d'appliquer certaines opérations sur les images bitmap.
Elle permet de :

• lire des fichiers images et les afficher sur l'écran ;
• enregistrer des images après 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 linéaires ,
  • zoomer / dézoomer l'image.

J'ai écrit cette application spécialement pour cet article, donc vous pouvez télécharger le code et l'améliorer suivant vos besoins.
L'application supporte seulement le format .jpg, vous devez donc modifier le code pour pouvoir gérer d'autres formats.
Pour comprendre les codes présents dans la partie qui suit, une connaissance de l'API SWING est nécessaire notamment la partie programmation par délégation et la gestion des événements.

L'application est composée de deux classes :
Classe Cadre :
cette classe représente la fenêtre principale de l'application.
Le constructeur de cette classe permet de créer trois menus :

• le menu « Fichier » contient un sous-menu « Ouvrir » qui permet d'ouvrir un fichier image stocké sur le disque et un deuxième sous menu « Enregistrer » qui permet d'enregistrer une image sur le disque après modification ;
• le menu « Filtre » contient cinq sous menus qui présentent les principaux traitements applicables sur les images chargées depuis le disque ;
• le menu « Retailler » quant à lui, contient le sous menu « Zoomer » et « Dézoomer » permettant respectivement comme le nom de chacun l'indique d'agrandir ou de réduire la taille de l'image chargée.

Classe PanDessin :
Cette classe dérive de JPanel. Elle présente le panneau où seront affichées les images chargées par l'application.
Elle admet un attribut unique monImage de type BufferedImage qui présente à tout moment l'image chargée affichée dans le panneau.
Cette classe présente le cœur de l'application. Ses méthodes permettent de modifier les images.

BufferedImage monImage = null;

protected void reduireImage(){
}
protected void agrandirImage(){
}
protected void imageConvolue(){
}
protected void imageEclaircie(){
}
protected void imageSombre(){
}
protected void imageBinaire(){
}
protected void imageEnNiveauGris(){
}
protected void modifierImage(){
}
protected void ajouterImage(File fichierImage){
}
protected BufferedImage getImagePanneau(){
}
protected void enregistrerImage(File fichierImage){
}

Les opérations de traitement sont déclenchées suite aux appuis sur la commande correspondante dans la barre de menus.
Par exemple si vous voulez ouvrir une image comme une opération de début, il faut sélectionner le menu « Fichier » et cliquer ensuite sur le sous-menu « Ouvrir » et de la même façon pour les autres opérations.
La création 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);
		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 dernière instruction du constructeur permet d'associer un objet de la classe PanDessin à l'objet Cadre, ce qui permet d'ajouter un panneau à notre fenêtre. Ce panneau sera ensuite la zone d'affichage des images.
Selon le principe de programmation par délégation, un appui sur l'un des sous-menus, fait appel à la méthode actionPerformed() :

public void actionPerformed(ActionEvent )

Selon le sous-menu sélectionné, cette méthode fait appel à la méthode 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 mathématique suivant un masque donné
	panneau.imageConvolue();
} 
else if (cliqueMenu.getSource().equals(agrandirMenu)) 
{
	// Agrandir l'image
	panneau.agrandirImage();
} 
else if (cliqueMenu.getSource().equals(reduireMenu)) 
{
	//reduire la taille de l'image
	panneau.reduireImage();
}
}

La méthode ajouterImage() de la classe PanDessin permet de lire un fichier image. Elle prend en paramètre 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 grâce au constructeur de la classe File qui prend en paramètre le chemin du fichier.

File fichierImage = new File("C:\\duke.jpg"));

La méthode statique read() de la classe ImageIO permet de charger une image en mémoire depuis ce fichier en lui associant un objet BufferedImage. Cette méthode attend que l'image soit entièrement chargée 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 décrire le contenu des fichiers images y compris les métadonnées ;
• ImageReader, ImageReadParam et ImageTypeSpecifier : pour contrôler le processus de lecture d'image.
• ImageWriter et ImageWriteParam : pour contrôler 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 utilisés pour représenter des images numériques. 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 supportés sont GIF, PNG, JPEG, BMP, WBMP.

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 "numéro magique" qui se trouve dans les premiers octets, et qui identifie le format du fichier.
Lorsqu'un lecteur adapté ne peut être trouvé ou si le lecteur ne parvient pas à décoder le contenu du fichier, la méthode read() renvoie null.
D'autres formats comme le format TIFF peuvent être traités par l'installation de fichiers JAR contenant des plug-ins qui une fois installés, permettront qu'un nouveau format sera automatiquement compris, sans aucune modification du code de l'application.
Chaque format d'image à son avantage et son inconvénient :

On peut utiliser la méthode getReaderFormatNames() pour connaitre les formats supportés en lecture :

String names[] = ImageIO.getReaderFormatNames();
for (int i = 0; i < names.length; ++i) 
{
	System.out.println(" fomat supportée en lecture :" + names[i]);
}

Ce code retourne uniquement les formats supportés en standard et aucun des plug-ins supplémentaires ne sera mentionné.

Après avoir lu le fichier de l'image avec la méthode read() et obtenu un objet BufferedImage pour la représenter en mémoire, elle peut être maintenant affichée dans notre panneau.
La méthode paintComponent() du panneau est spécialisée dans l'affichage des éléments graphiques qui se trouve dans la surface du panneau. Cette méthode est automatiquement sollicitée dès que nous avons besoin d'afficher ou de réafficher la fenêtre de l'application.
Nous devons donc passer par cette méthode pour être sûr que notre image soit réaffichée au moment du rafraîchissement.

protected void paintComponent(Graphics g)
{
	super.paintComponent(g);
	if(monImage != null)
		g.drawImage(monImage, 0, 0, null);		
} 

Pour afficher notre image, il faut utiliser la méthode :

drawImage(Image img, int x, int y, ImageObserver observer)  

de la classe java.awt.Graphics.

• le premier paramètre de la méthode doit être de type Image ou un type dérivé. Dans notre cas, l'objet monImage est de type BufferedImage, elle fait référence à l'image en mémoire.
• x et y : présentent les coordonnées du point haut gauche de l'image.
  
  
  
  
• observer : utilisée pour mettre à jour l'affichage de l'image lors d'un téléchargement d'une façon asynchrone. Ce paramètre 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); 

Une image peut être dessinée dans la surface d'un panneau, comme elle peut être elle aussi, une surface pour dessiner des formes 2D ou même des images.
On peut dessiner des formes géométriques comme des cercles, des polygones dans une image en utilisant les méthodes de dessin fournies par Java 2D comme fillOval() ou fillPolygon() :

	BufferedImage image = new BufferedImage(width_image, height_image, BufferedImage.TYPE_INT_RGB);
	// on récupère 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 coordonnées (30,30) 
	int Rayon = 200 ;
	g.fillOval( 50, 50, Rayon, Rayon );
	// on libère la mémoire utilisée pour le contexte graphique 
	g.dispose();
	 
	 

la première instruction permet de créer une image vide. On spécifie 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 spécifiés par un entier décrivant les valeurs de rouge, de vert et de bleu sans prendre en considération la couche alpha.
Les types d'images indiquent comment les couleurs des pixels sont codés. Vous trouvez une liste des différents types pris en charge par la classe BufferedImage ici.

IV-E-1. Réduire la taille de l'image▲

protected void reduireImage()
{
	// créer une nouvelle image qui contient les mêmes données de l'image source mais ayant //une taille réduite 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 spécifier le rapport suivant les axes x et y.
	// la valeur 0.5 présente le coefficient de multiplication.

	AffineTransform reduire = AffineTransform.getScaleInstance(0.5, 0.5);

	// AffineTransformOp effectue une transformation géométrique 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 présente 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 après changement
	repaint();
}

IV-E-2. Récupérer les pixels de l'image▲

	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]); 
	 

	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 ▲

	int xPixel = 100 ;
	int yPixel = 100 ;
	WritableRaster trameModifiable = monImage.getRaster();
	ColorModel modèleCouleur = monImage.getColorModel();
	int rgb = Color.white.getRGB();
	Object couleurBlanc = modèleCouleur.getDataElements(rgb, null);
	// la pixel qui se trouve à la position (100,100) va prendre la couleur blanche
	trameModifiable.setDataElements(xPixel, yPixel,  couleurBlanc);
	

IV-E-4. Binarisation de l'image▲

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 après changement
	repaint();
}

IV-E-5. Convolution mathématique▲

float[ ] masqueFlou = 
{
	0.1f, 0.1f, 0.1f,
	0.1f, 0.2f, 0.1f,
	0.1f, 0.1f, 0.1f
};

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 opération = new ConvolveOp(masque);
	opération.filter(monImage, imageFlou);
	monImage = imageFlou;

	// Appel à repaint pour activer l'affichage du panneau et visualisation
	// de l'image sur le panneau après changement

	repaint();
}

float[ ] masqueFlou

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

Finalement, notre image source définie par un objet BufferedImage qu'on a obtenu déjà a partir d'un fichier sur le disque, a subi différentes transformations.
On peut donc conclure que les données de l'image source sont modifiées et que son tableau de pixels (trame) stocké dans la mémoire a changé de valeurs. On obtient alors une image affichée sur la surface du panneau différente de l'image initialement chargée.
Il faut donc penser à enregistrer cette nouvelle image localisée dans la mémoire sur le disque.
Une manière de le faire consiste à créer une image à partir de la surface du panneau (objet de PanDessin) et enregistrer cette image dans un format donné. Pour créer cette image, on utilise la méthode getImagePanneau() :

protected BufferedImage getImagePanneau()
{      
	// récupérer une image du panneau
	int width  = this.getWidth();
	int height = this.getHeight();
	BufferedImage image = new BufferedImage(width, height,  BufferedImage.TYPE_INT_RGB);
	Graphics2D g = image.createGraphics();
	this.paintAll(g);
	g.dispose();
	return image;
}

Par la suite, on fait appel à la méthode enregistrerImage() qui permet d'écrire cette image sur le disque en utilisant la méthode 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 supportés en écriture par la classe ImageIO.
Pour récupérer ces formats on peut utiliser la méthode getWriterFormatNames() :

String[] names = ImageIO.getWriterFormatNames();
for (int i = 0; i < names.length; ++i) 
{
	System.out.println ("format supportée en ecriture : " + names[i]);
}

Cette méthode retourne uniquement les formats supportés en standard et aucun des plug-ins supplémentaires ne sera mentionné.
Avec ce dernier paragraphe, qui traite l'enregistrement d'image en Java 2D, on arrive à la fin de la présentation de l'application à travers laquelle j'ai essayé d'exploiter les fonctionnalités de l'API Java 2D fournis pour le traitement d'images. D'autres méthodes dans le code de l'application n'ont pas été mentionnées vu qu'il s'agit des mêmes traitements expliqués plus haut avec une élémentaire modification dans le code.