Le traitement d’images est une tâche complexe qui nécessite une connaissance approfondie des différents formats d’images et des méthodes de conversion. Dans ce contexte, le traitement d’images avec Javacv « inline » est une méthode très pratique pour convertir un IplImage 16S (16 bits non signés) en un IplImage 8U (8 bits non signés). Cet article expliquera en détail comment procéder à cette conversion et les avantages qu’elle offre.
Processing : Javacv « inline » : Convertir un IplImage 16S (16 bits non signés) en un IplImage 8U (8 bits non signés)

Explications
- Dans ce programme (basique!) , on réalise la conversion d’un objet IplImage 16S en objet IplImage 8U à l’aide de la fonction native OpenCV cvConvertScale().
- Ce programme crée 2 objets IplImage, l’un source 16S et l’autre destination 8U. On charge tous les pixels du IplImage source avec une valeur donnée et on affiche le résultat obtenu pour s’assurer du bon résultat de la conversion.
- Cette procédure est utile lors de l’utilisation de certaines fonctions natives OpenCV qui nécessitent l’utilisation d’un IplImage 16S en destination (par exemple la fonction cvSobel() ). Pour pouvoir l’afficher ensuite dans Processing, il est nécessaire de repasser en 8 bits non signés (8U).
Matériel et configuration utilisés
- PC Intel Core Quad 2.33 Ghz
- Ubuntu 10.04 LTS
- Processing 1-5
- OpenCV 2.3.1
- librairie javacv
Ressources utiles
- La documentation de la librairie OpenCV : http://opencv.itseez.com/
- La dernière version de la librairie OpenCV : Compilation/Installation d’OpenCV 2.3.1 sous Ubuntu 10.04 – PDF
- La librairie javacv, implémentation Java de la librairie openCV : http://code.google.com/p/javacv/ Cette librairie implémente en langage Java l’ensemble des fonctions et objets de la librairie openCV (écrite en C/C++) en langage Java. Cette librairie permet d’accéder relativement simplement aux fonctions d’openCV directement dans Processing notamment. Voir : Installation de la librairie javacv dans Processing – PDF
- Ma javadoc de la librairie javacv
Le programme
// généré avec le générateur de code Processing
// du site www.mon-club-elec.fr
// par X. HINAULT – tous droits réservés
// Programme écrit le : 8/10/2011.
// ——- Licence du code de ce programme : GPL v3—–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/////////////// Description du programme ////////////
// Utilise la librairie javacv qui implémente les fonctions natives d’OpenCV en Java
/*
Convertir un IplImage 16S en un IplImage 8U
*/
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import com.googlecode.javacv.*; // importe librairie javacv
import com.googlecode.javacv.cpp.*; // importe librairie javacv.cpp
// librairie javacv par Samuel Audet : http://code.google.com/p/javacv/
// javacv implémente en Java les centaines de fonctions natives de la librairie OpenCV (2500 algorithmes) !
// les fonctions de javacv sont dès lors facilement utilisables « in line » dans le code Processing
// la librairie doit simplement être présente dans le répertoire Processing /mode/java/libraries/javacv/library/
// NB : La librairie javacv est basée sur la librairie javacpp du même auteur : http://code.google.com/p/javacpp/
import com.googlecode.javacpp.*; // importe librairie javacpp (à distinguer de javacv.cpp.*)
// librairie javacpp par Samuel Audet : http://code.google.com/p/javacpp/
// la librairie doit être présente dans le même répertoire /mode/java/libraries/javacv/library/
//– autres librairies utiles avec javacv —
import java.awt.image.BufferedImage; // importe la classe java BufferedImage
import java.nio.*; // pour classe ByteBuffer
import java.awt.Rectangle; // importe la classe Rectangle du langage Java
// l’objet rectangle fournit les champs x,y du centre et hauteur/largeur (height/width) du rectangle
// déclaration objets
PImage imgSrc, imgDest; // déclare un/des objets PImage (conteneur d’image Processing)
opencv_core.IplImage iplImgSrc, iplImgDest; // déclare un/des objets IplImage (conteneur image natif librairie OpenCV)
// déclaration variables globales
//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);
// variable pour la taille de la capture video
int widthCapture=320; // largeur capture
int heightCapture=240; // hauteur capture
int fpsCapture=20; // framerate (image/secondes) pour la capture video
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// —- initialisation paramètres graphiques utilisés
colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
fill(0,0,255); // couleur remplissage RGB – noFill() si pas de remplissage
stroke (0,0,0); // couleur pourtour RGB – noStroke() si pas de pourtour
rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
ellipseMode(CENTER); // origine cercles / ellipses : CENTER : centre (autres : RADIUS, CORNERS, CORNER
//strokeWeight(0); // largeur pourtour
frameRate(30);// Images par seconde – The default rate is 60 frames per second
// — initialisation fenêtre de base —
size(widthCapture,heightCapture); // ouvre une fenêtre xpixels x ypixels
background(0,0,0); // couleur fond fenetre
// — initialisation des objets et fonctionnalités utilisées —
//======== Code exemple utilisation javacv « in line » =========
//— chargement d’un fichier image
//String cheminFichier= »/home/hinault/Bureau/trans/monimage.png »; // chemin absolu du fichier utilisé
//iplImgSrc= opencv_highgui.cvLoadImage(cheminFichier); // chargement d’un fichier dans l’IplImage
// création IplImage source 16S, 3 canaux
opencv_core.IplImage iplImgSrc= opencv_core.cvCreateImage( opencv_core.cvSize(width,height), opencv_core.IPL_DEPTH_16S , 3); // crée une image IplImage 16S / 3 canaux
// — le champ opencv_core.IPL_DEPTH_16S correspond à 1 codage 16 bits signés de l’image
// — on utilise ici 3 canaux —
// — les canaux des pixels de l’image 16S peuvent prendre des valeurs entre -32 768 / +32 767
//— création d’une image IplImage destination —
opencv_core.IplImage iplImgDest= opencv_core.cvCreateImage(opencv_core.cvSize(width,height), opencv_core.IPL_DEPTH_8U, 3); // crée une image IplImage 8bits , 3 canaux
// — le champ opencv_core.IPL_DEPTH_8U correspond à 1 codage 8 bits non signés de l’image
// — on utilise ici 3 canaux —
// — les canaux des pixels de l’image 8U peuvent prendre des valeurs entre 0/255
//— chargement des valeurs de départ
opencv_core.cvSet(iplImgSrc, opencv_core.cvScalarAll(32767)); // charge tous les pixels avec (val,val,val)
//opencv_core.cvSet(iplImgDest, opencv_core.cvScalarAll(0)); // charge tous les pixels avec (0,0,0)
opencv_core.cvZero(iplImgDest); // charge charge tous les pixels avec (0,0,0)
//—- conversion de 16S vers 8U —-
//— par ex : en partant d’une image 16S à (0,0,0) on doit théoriquement obtenir une image 8U à (128,128,128)
//— pour passer de 16 bits S à 8 bits U => /256 et ajouter 128… (cf -32768/256 = -128)
//double coeff=0.00390625; // passer de 16bits à 8 bits => diviser par 256
double coeff=1.0/256.0;// passer de 16bits à 8 bits => diviser par 256
//— attention : 1/256 pose problème..
double delta=128.0; // décalage
opencv_core.cvConvertScale(iplImgSrc, iplImgDest,coeff,delta); // fonction cvConvertScale
print(« Val Src (0,0) : R = »+opencv_core.cvGet2D(iplImgSrc, 0,0).val(0)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
print( » G = »+opencv_core.cvGet2D(iplImgSrc, 0,0).val(1)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
println( » B = »+opencv_core.cvGet2D(iplImgSrc, 0,0).val(2)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
print(« Val Dest (0,0) : R = »+opencv_core.cvGet2D(iplImgDest, 0,0).val(0)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
print( » G = »+opencv_core.cvGet2D(iplImgDest, 0,0).val(1)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
println( » B = »+opencv_core.cvGet2D(iplImgDest, 0,0).val(2)); // lit la valeur… utilise fonction .val(i) du scalar renvoyé par cvGet?D
//— affiche IplImage dans Processing via un PImage —
imgDest=toPImage(iplImgDest); // transfère IplImage dans PImage
image(imgDest,0,0); // affiche le PImage
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
//—- fonction toPimage : transfère un IplImage dans un PImage
PImage toPImage (opencv_core.IplImage iplImgIn) { // reçoit un IplImage et renvoie un PImage
//— récupérer l’objet IplImage dans un BufferedImage
BufferedImage bufImg=iplImgIn.getBufferedImage(); // récupère IplImage dans un objet BufferedImage transitoire
//—- créer un PImage —
PImage imgOut = createImage(iplImgIn.width(),iplImgIn.height(), RGB); // création d’un PImage de même taille que IplImage
// charge les pixels de l’image buffer dans le tableau imgOut.pixels du PImage
bufImg.getRGB(0, 0, iplImgIn.width(), iplImgIn.height(), imgOut.pixels, 0,iplImgIn.width());
imgOut.updatePixels(); // met à jour le PImage
return(imgOut); // renvoie le PImage
} // fin toPImage
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
Articles Liés
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…
- Javascript : Graphique Dygraphs : afficher date à partir unixtime
Le langage de programmation Javascript est très populaire et est utilisé pour créer des applications…