Enseignement en imagerie numérique

Gilles Gesquière

Ces pages s'adressent à des personnes désirant en savoir plus sur le domaine de la modélisation géométrique en synthèse d'images. Une case du tableau ci dessous correspond à une notion abordée.

Cours N °1 : Une introduction à la synthèse d'images

Cours N °2 : Une introduction à la programmation en OpenGL

  • Le document que vous trouverez en suivant ce lien est le guide de référence à OpenGL, plus communément appelé le Red Book. Télécharger la documentation OpenGL (redBook).
  • Lire le document d'introduction à OpenGL. Les fichiers Hello.cpp Primitives.cpp, Primitives2.cpp et teapots.cpp peuvent être nécessaires.
  • En environnement de programmation, vous pouvez éventuellement utiliser Visual C++ 6, ou Visual.Net. Dans ce dernier cas, voici une documentation qui explique comment créer une solution utilisant de l'OpenGL avec Visual.Net . Voici un exemple de projet déjà prêt Projet VisualContenant cet exemple)
  • Si vous voulez utiliser Dev C++, vous trouverez en créant un nouveau projet la possibilité de faire un projet multimédia (OpenGL). Afin d'utiliser directement les exemples OpenGL fournis sur internet, le plus simple est d'ajouter un package supplémentaire que vous trouverez sur le site http://www.nigels.com/glt/devpak/. Après téléchargement, pour les installer il faut utiliser Dev-C++ (commande Outils > Package Manager > Install ).
  • Si vous souhaitez utiliser Linux, il suffit de taper la commande suivante : g++ Hello.cpp -o Hello -lGLU -lGL -lglut ; Pensez à installer OpenGL Utility Toolkit (freeglut3, freeglut3-dev et libglut3 sous ubuntu par exemple). Vous pouvez ensuite tester le programme d'exemple Hello.cpp

Cours N°3 : Une introduction à la programmation en OpenGL (suite)

  • Lire la documentation : Découverte d'OpenGL (II). Cette partie est inspirée du cours d'Eric Bittar (http://www.univ-reims.fr/Labos/LERI/). Elle complète le cours d'OpenGL présenté dans la partie N°3. 
  • Vous pouvez faire les exercices d'application. L'objectif est de comprendre les différentes mises en forme, couleurs, paramètres et états possibles en OpenGL. Vous pouvez utiliser l'exemple suivant pour faire ces exercices (Carre.cpp, Projet VisualContenant cet exemple). Si nécessaire, voici la librairie Glut  (pour windows). Pour simplifier, il faut que les DLL, LIB et .H soient dans le répertoire courant (il y a mieux, mais il faut avoir les droits d'administration ce qui ne sera pas forcément votre cas autre part que sur votre PC personnel). 

Cours N°4 : Courbes et surfaces paramétriques

  • Lire le document de cours sur les courbes paramétriques
  • Faire les exercices de cet énoncé.
  • Voici un programme de l'université de Michigan (http://www.umich.edu/). Suivez ce lien afin de télécharger le programme.
  • Dans les exercices suivants, vous aurez besoin d'une classe point (3D). Implémentez cette classe pour le prochain créneau. Pensez à surcharger les opérateurs *, +, = ... Si vous ne l'avez pas fait, en voici une classe point3D
  • Nous allons travailler sur les courbes de Bézier. Voici l'énoncé. Voici un squelette du programme que l'on vous propose d'écrire. La gestion des touches est déjà faite. Vous pouvez trouver des informations sur la gestion des touches dans le cours N°8, Notions avancées d'OpenGL.

Cours N°5 : Les Quadriques

  • Lire le Cours représentations surfaciques
  • Voici l'énoncé de TD lié à ce cours.
  • Exercice à Programmer en OpenGL en vous aidant du squelette suivant Squelette Cylindre (SqueletteCylindre) :
    • Ecrire un programme permettant de visualiser un cylindre en OpenGL. Le cylindre aura une hauteur h et un rayon r. La même technique que celle utilisée dans l'énoncé de TD précédent sera utilisée (le cylindre sera créé en s'appuyant dans un premier temps sur deux cercles).
      1. Représenter les points qui composent les cercles de ce cylindre. Le nombre de point devra être paramétrable : il faut alors changer le nombre de points qui décrivent chaque cercle..
      2. Représenter les facettes permettant de relier ces points.
      3. Créer les bouchons afin de fermer ce cylindre.
      4. Ajouter des contrôles (à l'aide de touches) permettant de faire varier r, h, le nombre de point de chaque cercle, ainsi que le nombre de cercles sur le cylindre (On fait ainsi varier le nombre de facettes du corps et des bouchons).
    • Ecrire un programme permettant de facettiser une sphère de rayon r et de centre C. Vous pourrez commencer par afficher la liste des points composant la sphère pour ensuite relier ces points entre eux

Cours N°6 : Surfaces paramétriques

Cours N°7 : Représentation volumique des objets

  • Lire le cours N°07
  • Créer une représentation volumique de la sphère avec la méthode d'énumération spatiale (On englobera cette sphère avec une boîte englobante. Le nombre de cube de l'énumération spatiale sera défini en subdivisante cette boîte).
  • Modifier le programme afin de pouvoir ajouter plusieurs sphères (2 au départ) (Une boîte englobe alors les deux objets).
  • Créer des opérateurs de mélanges (union intersection) qui permettent de gérer les intéractions entre les sphères (par exemple pour l'intersection, on affiche un cube si et seulement si il appartient aux deux sphères).
  • Mettre en place un système de calcul d'une boîte englobant la scène. Modifier le programme afin que la taille du cube reste fixe quelque soit la taille de la boîte englobante (on ne divise plus la boîte en fonction du nombre de cube. Le cube a une taille fixée par l'utilisateur). La taille de la boîte englobante évolue en effet en fonction de la position des sphères et de leur rayon. On doit pouvoir régler la taille de ces cubes.
  • Généraliser le programme afin de pouvoir stocker une liste de n sphères (n est paramètrable).
  • Afin de minimiser le coût mémoire lié à l'énumération spatiale, nous proposons d'utiliser des cubes de tailles différentes organisés hiérarchiquement sous la forme d'un octree (arbre octal : un père a 8 fils). Implémentez cette technique pour une sphère par exemple. Cette technique nécessite les informations suivantes :
    • On décide qu'un cube est à l'intérieur, à l'extérieur ou indéterminé, en fonction du nombre de sommet dans ou hors l'objet.
    • Si un cube est à l'intérieur, on l'affiche avec la bonne valeur d'arête. Si un cube est à l'extérieur, on l'ignore. S'il est indéterminé, on le subdivise en 8 cubes.
    • Le critère d'arrêt peut être sur la taille d'une arête, ou sur la profondeur de l'arbre
  • Dans le cadre des objets définis par énumération spatiale, réutilisez le code précédent afin de créer les opérations Union et intersection. Prévoir la création de plusieurs objets qui seront stockés dans un arbre CSG. Visualisez le résultat. Le placement des objets se fera par déclaration dans le code. Aucune intéraction n'est ici demandée.

Cours N°8 : OpenGL Notions avancées

Cours N°9- Utilisation d'openscenegraph (www.openscenegraph.org)

Cours N°10 : Cylindre généralisé

  • L'objectif de ce cours est d'étendre la notion de cylindre commencée dans le cours N°5.
  • Voici les l'énoncé de ce TP.

Cours N°11 : Repère de Frenet

  • Voici deux références (en anglais) qui vous permettront de comprendre comment améliorer le cylindre généralisé proposé précédemment

Annexes 01:

  • Découverte de Visual .Net- Si vous voulez créer un projet sous visual. Net, vous pouvez utiliser la documentation présente à ce lien (pdf).

Annexe 02

  • Création de plug in sous 3dsMax. Lire la documentation suivanteFichier Basetsd.h (à remplacer ou à mettre dans votre répertoire courant)
  • Fichier sdkapwz (à ajouter dans C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\IDE
    si vous voulez ajouter l'appwizard pour 3dsmax)

 

 

Derniére modification : 11 août, 2014

Envoyez vos commentaires