// 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 320×240 — 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 320×240 (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