View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Outils > Processing

Processing : Javacv "inline" : Multiplication des pixels d'un IplImage par un coefficient.

Explications

  • Dans ce programme, on réalise la multiplication de tous les pixels d'une image par un coefficient, avec un coefficient identique ou différent pour chaque canal. Ceci est utile notamment pour réhausser une couleur par exemple.
  • On commence par créer une image intermédiaire dans laquelle on charge le scalaire des coefficients dans chaque pixel.
  • Ensuite, multilie les 2 IplImage, pixel par pixel grâce à la fonction native OpenCV cvMul().

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

Le programme


// Programme processing
// 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

/*
Multiplier tous les pixels d'un IplImage 8UC3 par une valeur fixe.
*/


// 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 d'une image IplImage destination ---
  opencv_core.CvSize mySize=iplImgSrc.cvSize(); // récupère la taille de l'image - Cvsize est un objet contenant 2 valeurs
  opencv_core.IplImage iplImgDest= opencv_core.cvCreateImage(mySize, iplImgSrc.depth(), iplImgSrc.nChannels()); // crée une image IplImage idem

  //--- création d'une image IplImage utilisée par la fonction
  opencv_core.IplImage iplImgTrans= opencv_core.cvCreateImage(mySize, iplImgSrc.depth(), iplImgSrc.nChannels()); // crée une image IplImage idem

  //---- solution 1 : charger un IplImage avec le scalaire des valeurs à utiliser et multiplier avec IplImage source
  // -- temps estimé : 2ms pour image 320x240 -- donc plus rapide
  // -- code plus simple et permet en plus de gérer facilement des coefficients différents pour les canaux

  double coeffR=1.0; // coeff à appliquer au canal Rouge
  double coeffG=1.0 ; // coeff à appliquer au canal Vert
  double coeffB=1.0;  // coeff à appliquer au canal Bleu

  println ("debut:"+millis());

  opencv_core.cvSet(iplImgTrans, opencv_core.CV_RGB(coeffR, coeffG, coeffB)); // remplit tous les pixels du IplImage avec le scalaire (coeffR, coeffG, coeffB)

  opencv_core.cvMul(iplImgSrc, iplImgTrans, iplImgDest, 1); // multiplie les 2 images

  println ("fin:"+millis());  

/*
  //---- solution 2 : utiliser une look-up table pour les nouvelles valeurs calculées (réduit théoriquement temps de calcul)
  // -- temps estimé : 5ms pour image 320x240 (donc paradoxalement plus long...)

  //int coeffR=2; // coeff à appliquer au canal Rouge
  //int coeffG=2;  // coeff à appliquer au canal Vert
  //int coeffB=2;  // coeff à appliquer au canal Bleu

  println ("debut LUT :"+millis());

  BytePointer myPtr = new BytePointer(256*3); // crée un pointeur de la taille voulue = nombre valeurs x nombres canaux

    opencv_core.CvMat matrix=  opencv_core.cvMat(1, 256, opencv_core.CV_8UC3, myPtr) ; // crée un CvMat avec taille de donnée unitaire 8 bits - 3 canaux
   //-- on crée un CvMat 8 bits / 3 canaux   car le CvMat doit avoir le même nombre de canaux et le même nombre bit (depth)
   // que le  IplImage source utilisé avec la fonction cvLUT()

   //--- met à jour le Cvmat avec les nouvelles valeurs calculées

        for( int i=0; i<256; i++ ) {

        int value = round( (float)(coeffR*i) );
                value=min(max(0,value),255); // équiv constrain 0-255
                opencv_core.cvSet1D(matrix, i, opencv_core.cvScalarAll(value)); // remplit les 3 canaux du CvMat à l'index voulu
        }

  //---- application du cvLUT en se basant sur le CvMat défini

   // static void       cvLUT(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr lut)
   opencv_core.cvLUT( iplImgSrc, iplImgDest, matrix );

   // cvLUT remplace dans l'image source chaque pixel par la valeur présente à chaque indice du tableau 1D CvMat utilisé
   // le résultat est mis dans la destination
   // ceci limite les opérations au calcul de 255 valeurs au lieu de faire widthxheight calculs identiques  
  println ("fin LUT :"+millis());  

*/
 

  //--- 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