introduction à l`ARToolkit, avec la version en java

DECOUVERTE DE L'ARTOOLKIT - VERSION JAVA
L'ARToolkit permet de reconnaître des patterns (tag) dans un flux vidéo. Elle permet aussi
d'incruster des éléments 3D (OpenGL) dans ce même flux vidéo. Son fonctionnement est
expliqué par les schémas ci-dessous.
Nous travaillerons avec un portage java de l'ARToolkit. Différentes documentations et
ressources vous seront utiles :
ARToolkit : en local ou http://www.hitl.washington.edu/artoolkit/documentation/index.html
OpenGL : http://www.opengl.org/sdk/docs/man/
Et http://www.opengl.org/resources/faq/technical/
GLUT : http://www.opengl.org/resources/libraries/glut/spec3/spec3.html
jogl : http://download.java.net/media/jogl/jogl-2.x-docs/index.html
NyARToolkit ( en japonais  ) : http://nyatla.jp/nyartoolkit/wiki/index.php?FrontPage.en
et http://sixwish.jp/Nyartoolkit/Java/section01.en/
L'objectif du tp est de vous faire découvrir l'ARToolkit, notamment ses capacités. Voici les
étapes du tp (prise en main, appropriation par modifications légères, étude de la complexité par
modifications conséquentes) :

1) Installation
a. Jogl
i. Les fonctions OpenGL (gl<quelquechose>) s'utiliseront avec un objet de
type GL (this._gl.gl<quelquechose>)
ii. Les fonctions GLUT (glut<quelquechose>) s'utiliseront avec un objet de
type GLUT (this._glut.glut<quelquechose>). Le champ de classe _glut sera
à ajouter. Sa construction est simple : this._glut = new GLUT();
b. JMF
c. (eclipse)
d. Faire un projet dans Eclipse avec la version de NyARToolkit que vous avez
téléchargée. Dans la version Java, il n'y a pas d'outils de calibration. Le fichier de
calibration est générable avec la version C++ d'origine
2) Faire marcher jp.nyatla.nyartoolkit.jogl.sample.JavaSimpleLite
a. Régler les problèmes de chemin (Data)
b. Problème d'encodage des fichiers, en cas de modification, il faudra soit convertir
soit supprimer quelques commentaires…
c. Les grandes phases du programme :
i. main :
 chargement de fichiers de configuration (caméra, pattern)
 création de l'objet
ii. Constructeur :
 Création de la fenêtre
 Initialisation de la caméra (this._capture) dont abonnement aux
nouvelles images (this._capture.setOnCapture)
 Création de l'objet de détection de pattern (this._nya)
 Initialisation OpenGL (GLCanvas canvas = new GLCanvas(); et
canvas.addGLEventListener(this);)
iii. init (appel automatique via GLEventListener) :
 initialisation OpenGL (this._gl);
 gestion de l'ARToolkit
 lancement de la scène (this._animator.start();)
iv. reshape (appel automatique via GLEventListener)
 caméra et taille de la scène
v. display (appel automatique via GLEventListener) :
 vérification de la capture d'une image (cap_image.hasBuffer())
 effacement de la scène (this._gl.glClear)
 affichage de l'image caméra en fond
(this._glnya.drawBackGround(this._cap_image, 1.0);)
 si un tag est détecté…
i. on change de repère
ii. on dessine
vi. onUpdateBuffer (automatique via JmfCaptureListener)
 récupération de l'image
(this._cap_image.setBuffer(i_buffer))
 détection de pattern
(this._nya.detectMarkerLite(this._cap_image, 110); )
3) Faites un jar de l'NyARToolkit, que vous pourrez ajouter à vos futurs projets…
A ce stade, la prise en main est finie, vous commencez les modifications
4) Appropriation - 1 - configuration

a. Faites un nouveau projet, ajoutez donc le jar que vous venez de faire, créez une
classe comprenant le même code que JavaSimpleLite
b. Recopiez "Data"
c. Modifier pour que cela reconnaisse un autre pattern (kanji)
d. Testez différentes valeurs de seuil avec this._nya.getConfidence() pour voir
si les patterns sont bien reconnus.
e. Modifier quelques paramètres :
 Le paramètre 80 (taille du pattern) dans la construction du
détecteur : this._nya = new NyARSingleDetectMarker(this._ar_param,
i_ar_code, 80.0, this._cap_image.getBufferType());
 Le seuil dans
this._nya.detectMarkerLite(this._cap_image, 110);
5) Faites en sorte que le programme reconnaisse plusieurs patterns
 Notez qu'un détecteur ne peut reconnaitre qu'un pattern
 Il faudra passer plusieurs variables sous forme de tableau
 Il faudra insérer des boucles pour le traitement de ces variables…
A ce stade, on rencontre des difficultés entre autre à cause de l'opengl…
6) Appropriation - 3 - Modifier le dessin
a. Créez une fonction pour afficher trois sphères qui tournent autour d'un pattern
b. Pour dessiner une sphère : avec glutSolidSphere et donc un objet GLUT
c. Par décalage du repère : glTranslatef
N'oubliez pas les glPushMatrix et les glPopMatrix pour sauvegarder et
restaurer le repère courant.
d. Ajouter trois sphères de couleurs différentes qui forment un triangle
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_flash);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
où mat_fash et mat_ambient sont des tableaux de float de dimension 4.
e. Faire tourner ces sphères avec une rotation générale par glRotatef
7) En utilisant un TextRenderer (c.f. ci-dessous), affichez un texte (particulier) centré sur
un pattern.
class TextPanel {
private TextRenderer _tr;
public TextPanel(int i_size) {
this._tr=new TextRenderer(new Font("SansSerif", Font.BOLD, i_size));
}
public void draw(String i_str,float i_scale) {
this._tr.begin3DRendering();
this._tr.setColor(1.0f, 1.0f, 0.2f, 0.8f);
this._tr.draw3D(i_str, 0f,0f,0f,i_scale);
this._tr.end3DRendering();
return;
}
}
8) Affichez (System.out.println) les coordonnées du centre du pattern à l'écran
NyARDoublePoint2d o_out = new NyARDoublePoint2d();
detector.refSquare().getCenter2d(o_out);
System.out.println(o_out.x +" / "+ o_out.y);
Puis dessinez un triangle dont l'un des sommets est le centre du pattern :
Le repère 2D par défaut est centré au milieu de la fenêtre, les coordonnées sont
comprises entre -1 et 1, l'axe des x est horizontal et orienté vers la droite, l'axe des y est
horizontal est orienté vers le haut.
// changement de "contexte" d'affichage opengl…

// dessin du triangle
this._nya .glColor3f(1.0, 0, 0);
this._nya .glBegin(GL.GL_TRIANGLES);
this._nya .glVertex3f(...,...,...);
this._nya .glVertex3f(...,...,...);
this._nya .glVertex3f(...,...,...);
glEnd();
// remettre en place le "contexte" d'affichage opengl