View  Edit  Attributes  History  Attach  Print  Search


ACCUEIL | DOCUMENTATION | STRATEGIES | TESTS


Librairie JavacvPro

Classe OpenCV : updateMarkers()


Description

  • Cette fonction met à jour à partir d'un objet Multimarker (Nyar4Psg) les informations des markers (ou pattern) détectés dans un tableau d'objets de la classe Marker (Javacvpro). La classe Marker implémente de nombreux paramètres pour chaque marker (ou pattern) détecté : voir la classe Marker.
  • Une fois que la fonction updateMarkers a été appelée, les fonctions suivantes peuvent être utilisées :
    • distanceMarker()
    • distanceMarkers()
    • draw2DMarkers()
    • draw3DMarkers()
  • Cette fonction fait le "pont" en quelque sorte entre Nyar4Psg et la librairie JavacvPro en récupérant les informations sur les markers obtenues grâce à la librairie Nyar4Psg tout en ajoutant d'autres informations 2D et 3D utiles.
  • Cette fonction :
  • reçoit l'objet Multimarker utilisé pour la détection
  • le tableau d'objet Marker à utiliser pour stocker les informations des markers
  • Cette fonction nécessite l'installation préalable de la librairie nyar4psg qui implémente ARToolKit pour Processing :
  • Voir également :

Déclaration source java

public void updateMarkers(MultiMarker nyaIn, Marker[] markersIn, boolean debugIn)

Syntaxe

opencv.updateMarkers(MultiMarker nyaIn, Marker[] markersIn, boolean debugIn);

Paramètres

  • opencv : un objet OpenCV déclaré avec le constructeur OpenCV.
  • MultiMarker nyaIn : objet MultiMarker de librairie Nyar4Psg à utiliser pour la détection
  • Marker[] markersIn : tableau contenant les objets Marker à mettre à jour. Noter que le tableau Marker[] doit être de la même taille que le nombre de markers utilisés pour l'objet MultiMarker.
  • boolean debugIn : drapeau d'activation des messages de débug.

Valeur renvoyée

  • Les informations des objets Marker du tableau qui ont été détectés sont mis à jours (pas les autres).

Utilisation type

  • Pour mettre à jour les objets Markers suite à une détection grâce à un objet MultiMarker Nyar4Psg et disposer de nombreux paramètres 2D et 3D concernant les markers détectés.

Exemple


opencv.updateMarkers(nya, markersArray, false); // met à jour le tableau des paramètres 2D des markers - javacvPro
 

Exemple webcam


// 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 : 29/2/2012.

// ------- 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 GSVideo de capture et lecture vidéo
// Utilise la librairie javacvPro de traitement d'image et reconnaissance visuelle
// Utilise la librairie nyar4psg qui implémente ARToolkit dans Processing

/*
Détection du centre et du type d'un marker ARToolkit
*/


// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import codeanticode.gsvideo.*; // importe la librairie vidéo GSVideo qui implémente GStreamer pour Processing (compatible Linux)
// librairie comparable à la librairie native vidéo de Processing (qui implémente QuickTime..)- Voir Reference librairie Video Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://gsvideo.sourceforge.net/
// et ici : http://codeanticode.wordpress.com/2011/05/16/gsvideo-09-release

import monclubelec.javacvPro.*; // importe la librairie javacvPro qui implémente le traitement d'image avancé et la reconnaissance visuelle pour Processing
// cette librairie se base sur les fonctions java de la 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) !
// la librairie javacvPro doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// dispo ici : http://www.mon-club-elec.fr/pmwiki_reference_lib_javacvPro/pmwiki.php
// nécessite également que la librairie native OpenCV 2.3.1 soit installée sur votre ordinateur
// NB : compatibilité avec la plupart des fonctions de la librairie OpenCV pour Processing : http://ubaa.net/shared/processing/opencv/

import java.awt.*; // Classe Point, Rectangle , etc...

import jp.nyatla.nyar4psg.*; // La librairie NyARToolkit Processing library = ARToolKit pour Processing
// Cette librairie permet de détecter des pattern ou marker dans une image
// et d'analyser leur transformation de perspective
// nyAR4psg est à télécharger ici : http://sourceforge.jp/projects/nyartoolkit/releases/
// et à mettre dans le répertoire des librairies
// à noter : javacvPro intègre des fonctions utilisables directement avec nyar4psg

// déclaration objets

PImage imgSrc, imgDest; // déclare un/des objets PImage (conteneur d'image Processing)

GSCapture cam; // déclare un objet GSCapture représentant une webcam
// L'objet GSCapture étend PImage - se comporte comme un conteneur des frames issues de la webcam

OpenCV opencv; // déclare un objet OpenCV principal

PMatrix3D syst3D; // déclare une matrice 4x4 représentant un système de coordonnées 3D..

MultiMarker nya; // déclaration de l'objet principal pour reconnaissance des markers - nya pour nyArtoolkit

// 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*2; // largeur capture
int heightCapture=240*2; // hauteur capture
int fpsCapture=15; // framerate (image/secondes) pour la capture video

// NB : pour la détection des markers, on peut utiliser une grande résolution facilement.
// Le résultat sera quand même rapide... et la précision plus élevée.

//----- variables pour calibration webcam -----
 float ouvertureX=19.43; // ouverture largeur en degres - Hercules DualPix Exchange
//float ouvertureX=22.53; // ouverture largeur en degres -  Logitech C270

// calculé avec tan angle= largeur réelle / 2 * distance camera
// exemple Logitech C270 : 1/2 largeur réelle = 83cm  distance = 200 cm
// d'où tan angle = 0.415 et d'où angle = 22.53 deg

//--------- variables pour reconnaissance des Markers avec nyARToolkit  ---------------------

//----- chemin absolu fichier de paramètres de distorsion de la camera ----
//String camParamPath = "/home/hinault/Téléchargements/librairies_processing/nyar4psg-1.1.6/data/camera_para.dat";
String camParamPath = "/home/xavier/Téléchargements/processing-1.5/modes/java/libraries/NyAR4psg/data/camera_para.dat";
// utilise le fichier par défaut - donne résultat satisfaisant

//----- chemin absolu fichiers de description des patterns ou markers ----
String patternPath = "/home/xavier/Téléchargements/patternMaker/examples/ARToolKit_Patterns";
// à télécharger ici : http://www.cs.utah.edu/gdc/projects/augmentedreality/

//--- taille de l'image à utiliser pour la détection = plus petite pour plus rapide ---
int widthAR= widthCapture;
int heightAR=heightCapture;

int numMarkers = 8; // le nombre de pattern ou markers différents à utiliser

Marker[] markersArray = new Marker[numMarkers]; // tableau pour stockage des paramètres des markers détectés avec ARToolkit - classe javacvPro !

float realWidthMarker=50; // taille réelle du marker utilisé en mmm - on aura un correspondance 1 mm = 1 pixel ou cran dans le repère 3D du marker

//String[] nameMarkers= new String[numMarkers]; // pour mémoriser le nom des marker


// 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,255); // 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,P3D); // ouvre une fenêtre xpixels  x ypixels - 3D active
        background(0,0,0); // couleur fond fenetre



// --- initialisation des objets et fonctionnalités utilisées ---

        //======== Initialisation Objets GSVideo (capture et/ou lecture video =========

        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        // cam1 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,"v4l2src","/dev/video0"); // Initialise objet GSCapture désignant webcam - avant GSVideo 1.0
        cam = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video1", fpsCapture); // Initialise objet GSCapture désignant webcam - depuis GSVideo 1.0
        // largeur et hauteur doivent être compatible avec la webcam - typiquement 160x120 ou 320x240 ou 640x480...
        // Meilleurs résultats avec framerate webcam entre 20 et 30 et frameRate programme idem ou multiple plus grand (40 pour 20 par ex)
        // la liste des webcam installées sous Ubuntu (Gnu/Linux) est donnée par la commande : ls /dev/video*

        // cam1.play();  // démarre objet GSCapture = la webcam - version GSVideo avant 0.9
        cam.start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9

        //======== Initialisation Objets OpenCV (librairie javacvPro : traitement d'image et reconnaissance visuelle) =========

        opencv = new OpenCV(this); // initialise objet OpenCV à partir du parent This
        opencv.allocate(widthCapture,heightCapture); // crée les buffers image de la taille voulue


      //---- exemple code ----
/*
    String nomFichier="/home/hinault/Bureau/trans/monimage.png";
      opencv.loadImage(nomFichier); // charge fichier dans le buffer opencv
      image(opencv.image(),0,0);// affiche le buffer opencv

    //opencv.contrast(100); // modifie contraste : -128/ +128
    //opencv.brightness(-50); // modifie luminosité : -128/ +128

    // opencv.copy(img); // charge le PImage dans le buffer opencv
    //opencv.cannyBuffer(); // applique filtre Canny et met le résultat dans le buffer Gray
    //opencv.sobelBuffer(3,2); // applique filtre Sobel sur le buffer
    //opencv.grayBuffer(); // bascule le buffer en niveau de gris

      image(opencv.getBuffer(),0,0); // alternative - affiche image stockée dans le buffer opencv

    //opencv.absDiff(); // réalise soustraction entre Buffer et Memory et met le résultat dans Memory2
    //opencv.gray("MEMORY2"); // transforme en niveaux de gris le buffer MEMORY2
    //opencv.invert("MEMORY2"); // inverse l'image du buffer MEMORY2
    //image(opencv.getMemory2(),0,0); // affiche image résultante stockée dans le mémory 2

    //opencv.rememberBuffer();  // mémorise le Buffer dans le buffer Memory
*/


     //=========== initialisation détection des markers =========================

     // création d'un objet MultiMarker avec résolution voulue, les paramètres caméra et le système de coordonnées voulu
        nya = new MultiMarker(this, widthAR, heightAR, camParamPath, NyAR4PsgConfig.CONFIG_DEFAULT);

   // fixe le nombre de fois qu'un marqueur ne doit plus etre détecté pour ne plus l'afficher.
     //Par défaut = 10. Mettre à 1 pour visualisation immédiate
      nya.setLostDelay(1);

      // fixe le niveau de seuil de détection à utiliser. Valeur possible entre 0 et 255. Mettre -1 (=THLESHOLD_AUTO) pour seuil automatique - respecter la "faute"
        nya.setThreshold(MultiMarker.THLESHOLD_AUTO);

        // fixe le niveau de seuil de confiance (= probabilité de correspondance) à utiliser pour la reconnaissance des markers. Valeur possible entre 0 et 1.
        // Valeur par défaut = 0.51 (=.DEFAULT_CF_THRESHOLD). Plus le seuil est élevé et plus la détection est rigoureuse.
        nya.setConfidenceThreshold(MultiMarker.DEFAULT_CF_THRESHOLD);
        //nya.setConfidenceThreshold(0.8); // sélection exigeante

        //-- chargement des fichiers de description des patterns

        //------- création des objets Marker individuel du tableau de markers (javacvPro)
        // et initialisation des propriétés communes
        for (int i=0; i<markersArray.length; i++) {
          markersArray[i]=new Marker();
          markersArray[i].realWidth=realWidthMarker;
        } // fin for

        //-------- initialisation du tableau d'objets marker (javacvPro)
        // chaque objet Marker de la librairie javacvPro contient les paramètres attachés au marker nyar correspondant
        // son nom = le fichier de description *.patt
        markersArray[0].name="4x4_99.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[1].name="4x4_50.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[2].name="4x4_83.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[3].name="4x4_23.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[4].name="4x4_68.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[5].name="4x4_76.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[6].name="4x4_55.patt"; // mémorise le nom du fichier du marker voulu
        markersArray[7].name="4x4_34.patt"; // mémorise le nom du fichier du marker voulu
        // etc...

        //---- chargement des markers dans le MultiMarker (nyartoolkit)---
        for (int i=0; i<markersArray.length; i++) {
          nya.addARMarker(patternPath + "/" + markersArray[i].name, markersArray[i].realWidth); // ajoute le fichier de description à l'objet principal de détection AR - bordure 25% et 16x16 par défaut
          println ("Fichier chargé : " + markersArray[i].name);
        } // fin for


} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle


// Code type capture GSVideo

  if (cam.available() == true) { // si une nouvelle frame est disponible sur la webcam

    background(0);  // fond noir entre 2 images

    //------ gestion image webcam par GSCapture ------
    cam.read(); // acquisition d'un frame
    image(cam, 0, 0); // affiche image
    //set(0, 0, cam); // affiche image - plus rapide


    //------- gestion détection et dessin 2D des Markers ----------

    nya.detect(cam); // detection des markers dans l'image à la résolution voulue - nyar4psg
    // l'image passée en paramètre doit avoir la même résolution que ce qui a été défini à l'initialisation du constructeur

    println("seuil de binarisation actuel = " + nya.getCurrentThreshold()); // affiche le niveau courant du seuillage binaire

    opencv.updateMarkers(nya, markersArray, false); // met à jour le tableau des paramètres 2D des markers - javacvPro

    //--- dessin 2D ---

   //public void draw2DMarkers(MultiMarker nyaIn, Marker[] markersIn, int xRefIn, int yRefIn, float scaleIn, int radius, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn, boolean debugIn)
   opencv.draw2DMarkers(nya, markersArray); // trace les markers - javacvPro

   opencv.distanceMarkers (nya, markersArray, ouvertureX, widthCapture, false);  // calcule et mémorise la distance réelle des Markers à la caméra - javacvPro

   // accéder aux caractéristiques 2D des markers ? - le centre, la rotation du marker sur lui-meme...
   // sélectionner un Marker voulu...


/* --- première possibilité --    
   if (nya.isExistMarker(3)) { // si le marker indice 3 est détecté

     println("Le marker " + markersArray[3].name + " est détecté !"); // le nom du fichier de description du marker

   }
*/


/*---- 2ème possibilité ---

   if (opencv.isExistMarker(nya, markersArray, "4x4_23.patt")) { // détecte si marker détecté à partir de son nom

          println("Le marker " + "4x4_23.patt"+ " est détecté !"); // le nom du fichier de description du marker

   }

*/



// ---- 3ème possibilité ----
   if (opencv.isExistMarker(nya, markersArray,23)) { // détecte si marker détecté à partir de son numero (pas l'indice)

         Marker selectedMarker = opencv.selectMarker(markersArray,23); // sélectionne le marker voulu

          println("Le marker " + selectedMarker.name + " est détecté !"); // le nom du fichier de description du marker

          println("Le centre est en x=" + selectedMarker.center2D.x + " | y="+ selectedMarker.center2D.y); // affiche les coordonnées du centre  


          opencv.drawCircle (
                    selectedMarker.center2D, // le centre du cercle à tracer
                        0, 0, // les coordonnées du cercle à tracer
                        1, // l'échelle à utiliser
                        10, // rayon à utiliser
                        jaune,1, // couleur et épaisseur du pourtour du cercle
                        true, rouge, // drapeau de remplissage et couleur de remplissage
                        false // drapeau d'affichage des messages
                                );


   }



/* // pour mémoire : les champs de l'objet Marker

         public String name             ="" ; // le nom du fichier de description du marker

         public float realX             = (float) 0.0; // abscisse réelle au sol de l'espace d'évolution décrit par les markers
         public float realY             = (float) 0.0; // ordonnée réel au sol de l'espace d'évolution décrit par les markers

         public float realWidth         = (float) 0.0; // largeur réelle du Marker

         public float width2D           = (float) 0.0; // largeur 2D du Marker telle que affichée sur l'image webcam
         public float height2D          = (float) 0.0; // hauteur 2D du Marker telle que affichée sur l'image webcam

         //--- pour réalité augmentée --
         public float width3D           = (float) 1000; // largeur 3D du Marker telle que affichée sur l'image webcam
         public float height3D          = (float) 1000; // hauteur 3D du Marker telle que affichée sur l'image webcam
         public float depth3D           = (float) 10; // profondeur 3D du Marker telle que affichée sur l'image webcam

         public float distance          = (float) 0.0; // distance du marker à la webcam (calculée)

         public float angleAxeY         = (float) 0.0; // angle de rotation dans l'axe Y en degrés


         public Point upCenter2D = new Point(); // milieu bord sup 2D du marqueur
         public Point downCenter2D = new Point(); // milieu bord inf 2D du marqueur
         public Point leftCenter2D = new Point(); // milieu bord gauche 2D du marqueur
         public Point rightCenter2D = new Point(); // milieu bord droit 2D du marqueur

         public Point center2D = new Point(); // centre 2D du marqueur

         public Point[] corners2D = new Point[4]; // coins 2D du marqueur
*/
       


    //---- dessin 3D ---
    //--- opération 3D à faire APRES détection 2D

    //--- affiche repère 3D centré sur l'écran ---
    //translate(width/2,height/2,0); // translation du repère 3D courant de pour centrage au centre de la fenêtre camera
    //opencv.drawCurrentSyst3D(50, color(255,0,0), color(0,255,0), color(0,0,255),2); // affiche le repère 0xyz courant avec taille et épaisseur voulus

    //void draw3DMarkers(MultiMarker nyaIn, Marker[] markersIn, int widthBoxIn, int heightBoxIn, int depthBoxIn, boolean strokeIn, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn, boolean debugIn)
    //opencv.draw3DMarkers(nya, markersArray,0, 0,10, false, 0, 0, true, color(255,0,0), true); // si width et height=0, utilise propriétés 3D de chaque marker

  } // fin if available


        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX


//------------- Fonction d'arret de Processing ----

public void stop(){ // fonction d'arrêt de Processing

        cam.delete(); // efface l'objet GScapture

        super.stop(); // obligatoire

} // fin fonction stop()


//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
 

Commentaires utilisateurs

Aucun

Cette page est une création originale de Xavier HINAULT - Tous droits réservés - 2011/2012