RAPPORT SUR LES PIXELS EN JAVA

asompheng40@hotmail.com

La plupart des images que nous avons utilisées précédemment en java étaient simplement lues à partir d’un fichier image. Je vais vous expliquer une autre technique pour construire des images, qui consiste à calculer une image pixel par pixel. Cette technique vous permettra de comprendre comment modifier les pixels d’une image lue.

Pour créer une image, construisez un objet BufferedImage (image en mémoire) :

BufferedImage image=new BufferedImage (largeur, longueur, BufferedImage.TYPE_INT_ARGB);

Maintenant, il faut appeler la méthode getRaster pour obtenir un objet de type WritetableRaster. C’est grâce à cet objet que l’on pourra modifier les pixels.

WritableRaster raster=image.getRaster() ;

ECRITURE :

Il existe plusieurs fonctions pour modifier les pixels :

- setPixel(int,int,int[4])

- setPixels(int x, int y, int largeur, int hauteur , int tab[4*largeur * hauteur])

ATTENTION : IL FAUT NOTER QUE LE TABLEAU DE PIXELS DE TYPE ‘INT’ EST PROPRE AU TYPE DE L’IMAGE, ICI LE TYPE EST TYPE_INT_ARGB.

VOICI UNE LISTE DES AUTRES TYPES :

- TYPE_INT_RGB

- TYPE_BYTE_GRAY

- TYPE_BYTE_INDEXED

- TYPE_USHORT_555_RGB … etc.

DONC LE TABLEAU DE PIXELS PEUT PRENDRE COMME TYPE: INT ou FLOAT ou DOUBLE.

Exemple :

BufferedImage image=new BufferedImage (largeur, longueur, BufferedImage.TYPE_INT_ARGB);

WritableRaster raster=image.getRaster() ;

int [ ] black={0,0,0,255}; // {R,G,B,Alpha}

raster.setPixel(3,4,black); // ici je choisit de colorier le pixel de coordonnée (3,4) en noir.

int l=5,h=5 ; // largeur et hauteur de la zone de pixels

int [ ] pixels=new int [4*l*h] ;

pixels[0]= 0 ; //valeur de rouge pour le premier pixel

pixels[1]= 0 ; //valeur de vert pour le premier pixel

pixels[2]= 0 ; //valeur de vert pour le premier pixel

pixels[3]= 255 ; //valeur alpha pour le premier pixel

// Initialisation des autres pixels par boucle FOR au hasard

int j=0;

for (int i=4 ;i<4*l*h ;i++) {

if (j%4==3) { pixels[i]=255; // Alpha toujours a 255 pour une opacité a 100%}

else { pixels[i]=(int)(Math.random()*256); // Choix des couleurs par un random}

j++ ;}

INVERSEMENT LECTURE:

Il existe plusieurs fonctions pour lire les pixels :

- getPixel(int,int,int[4]) // bien sur le tableau sera écrasé s’il n’est pas vide

- getPixels(int x, int y, int largeur, int hauteur , int tab[4*largeur * hauteur])

Les fonctions de lecture nous permettent donc de récupérer les valeurs des pixels des images. Et nous pourrons donc les modifier ou les intervertir. Pour notre projet, il suffira simplement de bien dérouler l’algorithme.

ICI S’ARRETE LA PARTIE OBLIGATOIRE A CONNAITRE

OPERATION SUR OBJET IMAGE :

Il existe en java l’objet BufferedImgaOp comme Opération sur Image en Mémoire, cet objet permet de faire des opérations telles que translation, rotation, éclaircissement, flou, etc… sur des images. Attention c’est une interface, donc elle a besoin d’être implémentée par d’autres objets. Son utilisation est assez simple, on entre une image comme source, et on lui donne une image en destination. Le fait de préciser une destination différente de la source est très important, car la plupart des opérations ont besoin de passer par une autre image.

Voici les 5 classes qui implémentent l’interface BufferedImageOp :

- AffineTransformOp // Opérations telles que rotation, translation..

- RescaleOp //Opérations telles que agrandissement..

- LookupOp // Opération telles que renverser les couleurs

- ColorConvertOp // Opération sur les couleurs

- ConvolveOp // Opération telles que ???

Exemples que vous déchiffrerez :

Rotation :

Avant de commencer, il faut rapatrier une Image dans image, vous devez déjà savoir le faire !

Et bien sur avoir un programme principal et tout et tout, ici ce ne sont que les fonctions principales.

void rotate( ) {

AffineTransform transform = AffineTransform.getRotateInstance(Math.toRadians(5),image.getWidth()/2, image.getHeight()/2) ;

AffineTransform op= new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR) ;

filter(op) ;

}

void filter(bufferedImageOp op) {

BufferedImage filteredImage = new BufferedImage(image.getWidth(),image.getHeight(), image.getType());

op.filter(image,filteredImage); //Traitement de l’image

image= filteredImage; // Enregistrement de lamodification

repaint() ; // Pour réactualiser l’image qui est dans un Panel ou JPanel

}

Détection de contour :

Plus difficile : la classe ConvolveOp se construis avec en paramètre un objet Kernel. Ne vous affolé pas, Kernel est une matrice qui détermine une opération en fonction de la classe choisit. Vous voyez que les mathématiques rentrent en jeux.

Pour créer un Kernel pour nos fonctions, généralement des matrices de 3 sur 3. Les deux premier paramètres sont les dimensions de la matrice. Jusqu’à la facile. Le troisième paramètre est un tableau de float, oui j’ai bien dit float et rien d’autres, donc je rappelle que pour mettre des int il faut faire, exemple : 3f équivalent à 3.0f équivalent à 3.f . Le tableau est donc de dimension 1, avec 3*3=9 valeurs.

Exemple :

float[ ] elements =

{ 0.0f, -1.0f, 0.0f

-1.0f, 4.f, -1.0f

0.0f, -1.0f, 0.0f } ;

Kernel kernel =new Kernel(3,3,elements);

ConvolveOp(kernel);

Op.filter(image, filteredImage);

Je m’arrête ici au niveau des exemples, il faut noter que chaque classe qui utilise l’implémentation BufferedImageOp n’a pas les même arguments en paramètre au moment de sa construction, et ne construise pas de la même manière.

VOILA C’EST FINI. SI VOUS AVEZ DES PROBLEMES DE COMPREHENSION, LE MIEUX EST DE SE REFERER A L’API JAVA POUR GARDER VOTRE ANONIMA, SINON VOUS POUVEZ TOUJOURS ME DEMANDER DES RENSEIGNEMENT PAR MAIL OU PAR TELEPHONE. JE VOUS RAPPELLE QUE MOI, C’EST ALEXANDRE.