Master 1 Informatique - UE M1if37 Animation en synthèse d'image (3 ECTS)

M1if37 est une UE optionnelle de la première année du Master d'Informatique de l'Université Lyon 1. Les cours ont lieu au semestre 2 (printemps). L'objectif de l'UE est de donner les bases de l'animation en synthèse d'images. Nous aborderons les deux grandes familles de méthodes. L'animation basée sur des données, par exemple pour l'animation d'humain virtuel (données issues de capture de mouvement). Et l'animation basée sur un modèle physique pour la simulation de phénomènes naturels comme le mouvement de textiles ou de fluide. L'UE laissera une grande part à l'application pratique avec la réalisation de TPs en C++/OpenGL proposant d'animer par exemple des humains virtuels, des vêtements, des cordes, une surface d'eau, etc.

Retour vers la page principale de l'UE M1if37

Supports pédagogiques de la partie "Animation par modèles physiques" - F. Zara

Evaluation du TP de la partie "Animation par modèle physique" - F. Zara

Voici ce que j'attends dans votre code :
  • Simulation du tissu soumis à la gravité
  • Déchirure du tissu
  • Interaction avec le coin du tissu
  • Collision avec une sphère
  • Collision avec le sol ou un plan incliné
  • Autre force comme le vent
  • Joli scène (texture, etc.)
  • Ne pas hésiter à ajouter d'autres éléments
Deux colonnes sur TOMUSS pour le rendu de la partie modèle physique :
- Si vous ne faites pas de démo, vous devrez mettre sur TOMUSS, dans la colonne Video-FZ, l'URL d'une vidéo servant de démo de votre code : vous devez montrer l'ensemble de votre travail (car je ne compilerai pas votre TP).

- Dans tous les cas, vous devrez déposer sur TOMUSS une archive de votre code dans la colonne Depot-FZ. Cette archive contiendra (mettre votre nom prénom comme nom du répertoire) :
  1. les fichiers de code que vous avez modifiés (fichiers .cpp et .h uniquement)
  2. un rapport de 5 à 10 pages.
En ce qui concerne le rapport, voici son contenu :
  1. Explication de la boucle de simulation permettant de réaliser l'animation d'un objet - en détaillant chacune des étapes (en donnant l'équation et les explications adéquates). Pour cela, imaginez que vous deviez expliquer à une personne qui n'a pas suivi le cours comment vous faites une simulation 3D.
  2. Explication du système masses-ressorts : démarche identique.
  3. Explication de tout ce que vous avez effectué dans votre code en plus de la simulation initiale : déchirure, mouvement d'un coin, collision avec un objet, etc.
  4. Une partie un peu plus libre (vous pouvez vous aider d'articles vus sur internet) : si vous aviez beaucoup plus d'heures pour améliorer votre projet, que feriez-vous ? Voici quelques idées non exhaustives : meilleure prise en compte des collisions : comment implémenter cela ? ; améliorer le système masses-ressorts (liaisons entre les ressorts, coefficient des raideurs, etc.) ; parallélisation des algorithmes sur GPU - sur multi-cpu.

Etape 1 - Récupération du code de départ

Nous vous fournissons un code de départ pour effectuer les TPs de la partie "Animation par modèle physique" - F. Zara.
Ce code est basé sur l'utilisation de la librairie gKit2light développée par Jean-Claude Iehl.

Vidéo : Présentation du code de TP

Voici les consignes pour récupérer le code de départ (gkit2light + code pour ce TP) :

    • Création d'un répertoire de travail dédié à l'UE
      • mkdir M2AnimationPhys
    • On se positionne dans ce répertoire
      • cd M2AnimationPhys

    • Le code de gkit2light se récupère ensuite avec Git comme ceci :
      • git clone https://forge.univ-lyon1.fr/Alexandre.Meyer/gkit2light

    • Le code de départ de M2 Animation Physique se récupère ICI :
      • Il faut décompresser l'archive
      • Puis mettre le répertoire animationphys dans le répertoire gkit2light/
    • Vous travaillerez ainsi dans le répertoire gkit2light/animationphys/.
    • Les fichiers C++ se trouvent dans gkit2light/animationphys/src/.

Etape 2 - Suivre ces consignes pour compiler le code

  1. On se place dans le répertoire gkit2light

  2. Vérifier que vous avez la commande premake5
    • Si vous ne l'avez pas :
      (1) récupérer la sur le site officiel
      (2) dezippez l'archive et copiez premake5 dans le répertoire de gkit2light
      (3) et il faut donner l'autorisation de l'exécuter :
      • chmod u+x ./premake5
  3. Dans le fichier gkit2light/premake5.lua, ajouter les lignes ci-dessous à la fin du fichier (si elles ne sont pas déja présentes) :
    4.  -- animationphys
if os.isfile("animationphys/src/premake5.lua") then
    include "animationphys/src"
end
  4. Si vous souhaitez utiliser codeblocks + Linux
    • Générer le projet codeblocks
      • premake5 codeblocks
    • Puis, ouvrir le projet animationphys.cbp
  5. Si vous souhaitez utiliser un Mac ou un Linux
    • Pour générer le Makefile (à ne faire qu'UNE seule fois)
      • premake5 gmake
    • Pour compiler (à faire à chaque fois que vous modifiez votre code)
      • make animationphys
    • L'exécutable de votre code sous Linux ou Mac sera :
      • ./bin/animationphys
  6. Pour compiler sous Linux de chez vous (ubuntu)
    • voir le apt-get install ... ici
    • Puis suivre les indications mises plus haut
    • Si probleme avec premake (qui est une application 32bits) pour l'executer sur un système 64 bits, il faut installer les librairies 32bits.
      • sudo apt-get install libc6-i386
  7. Si vous avez une erreur de compilation
    • Changez build target en debug|x32 au lieu de debug|x64
  8. Si vous avez une erreur de compilation sur les machines de l'université sous codeblocks
    • Vérifiez le compilateur utilisé par codeblocks : menu Setting/Compiler/Toolchain executable
    • C:\ProgramFiles\x86\CodeBlocks\MinGW
  9. Pour sauvegarder automatiquement sous vscode
    10. Préférences / Paramètres / éditeur de texte / Fichiers / Auto Save / onFocusChange

Etape 3 - Exécution du code depuis le répertoire gkit2light

  • Le programme nécessite de mettre en paramètres :
    • le nombre d'objets de la simulation
    • le fichier des paramètres généraux de la simulation
    • ainsi qu'un fichier de paramètres pour chacun des objets simulés.
  • Si vous lancez l'application sans paramètre, il prendra les paramètres mis directement dans le fichier animationphys/src/main.cpp.
  • Il faudra ainsi les modifier directement dans le code et recompiler, si vous souhaitez les changer.

  • Sinon, vous pouvez créer un fichier qui s'appelle go dans le répertoire gkit2light
    et mettre les instructions suivantes afin de donner les paramètres nécessaires :
    • ./animationphys/bin/animationphys 1 ./animationphys/exec/Fichier_Param.simu ./animationphys/exec/Fichier_Param.objet1
  • Pensez à le convertir en exécutable :
    • chmod +x go
  • Vous pouvez ainsi lancer le programme en tapant dans un terminal depuis le répertoire gkit2light
    • ./go
  • ou de manière générale :
    • ‹Executable› ‹nbObjet› ‹fichier param simulation› ‹fichier param Obj1› ‹fichier param Obj2› ...
  • Vous pouvez aussi utiliser votre logiciel de développement préféré, pour spécifier ces paramètres lors de l'exécution.

Etape 4 - Compréhension du code source

  • Votre code prendra place dans le répertoire
    • gkit2light/animationphys/src/
  • Pour générer la documentation Doxygen 
    • 
cd gkit2light/animationphys/
 doxygen ./Doxyfile
  • Lisez la documentation Doxygen à partir du fichier gkit2light/animationphys/doc/html/index.html
  • Le répertoire gkit2light/animationphys/data contient les données de la simulation :
    • textures : pour placer des textures
    • CreateMesh : programme pour créer des maillages de tissu ou convertir des fichiers .obj .off en fichiers pour l'application
    • drap10 : fichiers de données d'un tissu de 10 particules
    • drap70 : fichiers de données d'un tissu de 70 particules
    • vache : fichiers de données d'une vache
    • sphere : fichiers de données d'une sphère
    • bunny : fichiers de données du Standford bunny
  • Les sous-répertoires drap10/drap70/vache/sphere/bunny contiennent plusieurs fichiers :
    • faceset.eti : définition des facettes triangulaires de l'objet
    • masses.eti : définition des masses associées aux sommets de l'objet
    • points.eti : définition des coordonnées (x,y,z) des sommets de l'objet
    • texcoord.eti : définition des coordonnées de textures des sommets de l'objet
  • Le répertoire gkit2light/animationphys/exec contient les fichiers pour l'exécution de l'application :
    • Fichier_Param.simu : paramètres de la simulation - gravité, viscosité, nb itérations, type des objets simulés (mss, sph, pbd)
    • Fichier_Param.objet : paramètres de l'objet simulé - fichiers de données, k, nu, dt, etc.
    • Format des fichiers de paramètres :
      • une clé par ligne (`cle = valeur`)
      • Les commentaires `#`, `!` ou `//` en début de ligne sont ignorés
      • Les commentaires inline après `#` sont aussi supportés
      • Le point-virgule final est optionnel
  • Quelques explications lors du lancement de l'application
    • 'h' pour l'aide
    • 'n' pour faire apparaitre les normales
    • 'f' pour faire apparaitre les faces cachées
    • Mouvement possible de la lumière / caméra / d'un point du tissu

Sujet du TP - Animation de textiles

  • Modélisation du tissu

    • Le tissu est discrétisé par un ensemble de particules de masses mi=1 connectées entre elles par des ressorts de raideurs kij = 15000.0, de viscosité nuij = 0.01, et de longueur au repos lij = 0.1. La gravité et la viscosité du milieu sont également pris en compte pour simuler la scène. Ces paramètres sont notamment mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/animationphys/exec.

  • Boucle de l'animation
    • Calcul des forces appliquées sur les particules
    • Calcul des accélérations des particules au cours du temps, en utilisant la loi fondamentale de la dynamique
    • Intégration des accélérations pour obtenir les vitesses
    • Intégration des vitesses pour obtenir les positions
    • Affichage de l'objet simulé après lissage des normales
  • Travail à effectuer
    • Vous devez compléter le code de l'application pour simuler le mouvement d'un tissu carré discrétisé par 70 x 70 particules (fichiers de données dans le répertoire gkit2light/animationphys/data/drap70).
    • Le tissu est notamment fixé par deux coins. Comment ces coins ont été fixés ? Pour vous aider, vous pouvez regarder les fichiers de données relatifs à cet objet.
  • Vous pouvez débuter en utilisant des tissus de tailles plus petites en les générant à l'aide du programme CreateData du répertoire /gkit2light/animationphys/data/CreateMesh. Dans ce répertoire :
    • Makefile : pour compiler tous les programmes
    • CreateData.cpp : permet de créer les fichiers de données (format texte) relatifs à des carrés de tissu de taille paramétrable
    • obj2sappe.cpp, Donnees.h : permet de convertir les fichiers de données des facettes du format .obj au format utilisé par l'application
    • off2sappe.cpp, Donnees.h : permet de convertir les fichiers de données des facettes du format .off au format utilisé par l'application
    • scalepoints.cpp, Donnees.h : permet de modifier le fichier des positions des particules en les divisant par un facteur donné
  • Voici les étapes (détaillées ci-dessous) pour réaliser cette simulation
    1. Affichage de l'objet simulé
    2. Calcul des forces
    3. Calcul des accélérations
    4. Calcul des vitesses et des positions
    5. Animation du tissu
    6. Interaction avec l'utilisateur
    7. Déchirure
    8. Tombé de tissu

      Affichage de l'objet simulé

      • Complétez la fonction Viewer::initMeshObjetDeformable() pour créer le maillage de l'objet simulé.
      • Complétez la fonction Viewer::updateMeshObjetDeformable() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.
      Ces méthode se trouvent dans le fichier Viewer-mesh.cpp.

      Calcul des forces des ressorts

      • Quelles sont les forces qui sont exercées sur chacune des particules du tissu ?
      • Complétez la méthode void ObjetSimuleMSS::CalculForceSpring() servant à calculer les forces qui sont exercées sur chacune des particules. Pensez à prendre en compte les forces d'amortissement des ressorts.
      Méthode se trouve dans le fichier ObjetSimuleMSS.cpp.

      Calcul de la force de gravité et des accélérations

      • Complétez ensuite le code de l'application, pour calculer les accélérations des particules au cours du temps. Il s'agit de la fonction SolveurExpl::CalculAccel_ForceGravite présente dans le fichier SolveurExpl.cpp. C'est dans cette fonction que vous rajouterez également la force de gravité à l'ensemble des forces appliquées sur le particules.

      Calcul des vitesses et des positions

      • Complétez le code de l'application pour calculer par intégration numérique les nouvelles vitesses et positions des particules à partir des accélérations et des vitesses. Il s'agit de modifier la fonction SolveurExpl::Solve présente dans le fichier SolveurExpl.cpp. Implémentez tout d'abord le schéma d'Euler explicite. Puis, utilisez le schéma de leapfrog-Verlet ou le schéma d'Euler semi-implicite.
      • Comparer ces schémas d'intégration numérique en modifiant la taille des pas de temps. Lequel vous paraît le plus stable ?
      • Enfin, afin de dissiper les vitesses, multipliez-les par le coefficient de dissipation (ou de viscosité) qui est lié à la scène.

      Animation du tissu

      • Maintenant que les calculs des forces, accélérations, vitesses et positions ont été complétés, vérifiez que l'animation du tissu vous paraît cohérente. Vous pouvez notamment modifier les paramètres du vecteur gravité, la raideur des ressorts, etc. Vous pouvez rajouter des objets dans la scène, le rendu, etc. pour produire une belle animation.

      Interaction avec l'utilisateur

      • Modifiez l'application afin d'ajouter une interaction avec l'utilisateur. L'interaction avec le clavier (touche m enfoncée + flèches direction) doit permettre de faire bouger un des coins initialement fixe du tissu. Par exemple, vous pouvez modifier l'application pour que la position de la particule 0 soit déterminée par le mouvement de la souris. Regardez ce qui a été mis pour cela dans le fichier Viewer.cpp. Il s'agit ensuite de modifier la fonction ObjetSimule::Interaction du fichier ObjetSimule.cpp.

      Déchirure

      • Vous pouvez considérer que si la force appliquée à un ressort est trop importante (ou si sa longueur dépasse une certaine taille), le tissu se déchire c'est-à-dire que le ressort considéré est supprimé. Rajoutez le code qui permet de gérer cela.

      Tombé de tissu

      • Modifiez les fichiers de données relatifs au tissu de façon à ne plus avoir de points fixes c'est-à-dire que sous l'emprise de la gravité, le tissu doit tomber.
      • Ajoutez le code permettant de détecter et traiter la collision du tissu sur le sol (dont on connait son emplacement) en faisant en sorte que le tissu reste immobile sur le sol. Il s'agit de modifier la fonction ObjetSimuleMSS::Collision présente dans le fichier CalculsMSS.cpp.
      • Faire une belle scène avec plusieurs objets, des textures sur les objets, etc. Gérer les collisions entre les objets : tissu qui tombe sur une sphère, une table, un cube, etc.

Sujet de TP - Bonus

Si vous avez fini l'animation de tissu, vous pouvez réaliser l'Animation d'un système de particules soumis à la gravité et qui rentrent en collision avec la grille horizontale positionnée en y=0. Il faut alors faire compléter les méthodes de la classe ObjetSimuleParticule pour gérer ce type d'objets.

Galerie des projets d'étudiants