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


Responsables de l'enseignement : A. Meyer, N. Pronost et F. Zara (LIRIS-SAARA, Lyon 1)
Volume horaire : 12h CM, 18h TP

Objectif de l'UE

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.


Thématiques abordées


Emploi du temps - année universitaire 2019-2020


Modalités de contrôle des connaissances (MCC)

  • 3 notes de TP : TP F. Zara, TP A. Meyer, TP N. Pronost (code + démo en salle de TPs)
  • 1 note CCF : épreuve sur feuille portant sur les 3 parties
  • Coefficient : 40% TP, 60% CCF
  • Date de l'évaluation : mardi 23 juin 2020
    • Examen sur les 3 parties (8h-10h - salle ?? Nautibus)
  • Date des démo TP :
    • Démo TP sur les parties de Florence Zara et Alexandre Meyer : mardi 23 juin - 10h-12h - salles ??, ?? Nautibus
    • Démo TP sur la partie de Nicolas Pronost : mercredi 24 juin - 10h-12h - salles ??, ?? Nautibus

Contenu de la partie "Animation par modèles physiques" - F. Zara



Supports de TP

  • Animation par modèle physique - TP
  • Animation par modèle physique - TP

    1 - Récupération du code

    • Nous allons utiliser la librairie gKit2 light développée par Jean-Claude Iehl
    • Le code de départ (code source de la librairie gkit2light + code pour ce TP - répertoire gkit2light/src/master_MecaSim) se récupère avec Git comme ceci :
      
      git clone https://forge.univ-lyon1.fr/Alexandre.Meyer/gkit2light
      cd gkit2light/
      git checkout -b master_MecacSim origin/master_MecacSim
                                      

    2 - Compilation du code

  • Suivez ces instructions pour compiler les codes sources selon votre plateforme (Linux, MacOS, Windows)

  • 3 - Lancer l'application 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 qui ont été écrits directement dans le fichier gkit2light/src/master_MecaSim/src-etudiant/main.cpp. Il faudra ainsi les modifier directement dans le code et recompiler, si vous souhaitez les changer.
    • Sinon, nous avons créé un fichier qui s'appelle go dans le répertoire gkit2light
    • Nous avons mis dedans l'instruction suivante afin de donner les paramètres nécessaires :
    • 
      ./bin/master_MecaSim_etudiant 1 src/master_MecaSim/exec/Fichier_Param.simu src/master_MecaSim/exec/Fichier_Param.objet1
                              
    • Et pour le convertir en exécutable, nous avons fait :
    • 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> ...
                                   

    4 - Comprendre le code


    5 - Réaliser le TP

    • Travail à effectuer - Animation de textiles
    • Si vous avez fini - 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.

    6 - Evaluation du projet

    • Rendu du projet (avec démonstration) : mardi 23 juin 2020
    • Vous devrez également déposer sur TOMUSS une archive de vos fichiers sources dans la colonne Depot-FZ

    Compilation du code

    Pour compiler le code sous Linux - codeblocks
    
    cd gkit2light
    premake/premake4.linux --file=master_MecaSim.lua codeblocks
    ouvrir le projet master_MecaSim_etudiant.cbp
                
    Pour compiler le code sous Linux - makefile
    
    cd gkit2light
    premake/premake4.linux --file=master_MecaSim.lua gmake
    make -f master_MecaSim_etudiant.make
    ./bin/master_MecaSim_etudiant
                  
    Pour compiler sous Linux de chez vous (ubuntu)
    • Voir le apt-get install ici
    • Puis reprendre les instructions mises ci-dessus
    Pour compiler le code sous Mac - makefile
    
    cd gkit2light
    premake/premake4.macosx --file=master_MecaSim.lua gmake
    make -f master_MecaSim_etudiant.make
    ./bin/master_MecaSim_etudiant
                  
  • Pour compiler sous windows chez vous avec CodeBlocks
    • Installez Git avec tortoiseGit
    • Installez Codeblocks, la version 16 avec Mingw
    • Explorateur de fichier, placez vous dans le répertoire de vos fichiers, bouton droit menu 'TortoiseGit puis cloner', puis entrez le chemin Git indiqué plus haut commençant par https …
    • Téléchargez les librairies (SDL,Glew, etc.) pour windows ici, copiez le répertoire 'extern' dans le répertoire principale de gkit2light
    • Vous devez aussi copier toutes les .dll du répertoire extern/mingw/lib dans gkit2light/bin (répertoire des exécutables), sinon vous aurez des erreurs à l'exécution des programmes
    • Lancez le script gkitlight/premake/premake-meca.bat qui va créer les projets makefile/codeblocks dans le répertoire gkitlight
    • Ouvrez le projet gkitlight/master_MecaSim_etudiant.cbp
    • Remarque : le code exporté avec Git contient une version compilée des librairies (SDL2, glew, etc.) pour windows donc rien à installer
    Si vous avez une erreur de compilation
    • Changez build target en debug">x32 au lieu de debug">x64.
    • Si l'erreur provient de M_PI qui n'est pas reconnu (malgré le #include ), il faut rajouter le code suivant dans le fichier gkit2light/src/master_MecaSim/src-etudiant/Matrix.cpp juste après les includes
    
    #ifndef M_PI
    #define M_PI    3.14159265358979323846264338327950288   /* pi */
    #endif
                  

    Première étape - Compréhension du code de l'application

    • Votre code prendra place dans le répertoire
    • gkit2light/src/master_MecaSim/src-etudiant/
    • Pour générer la documentation Doxygen
    • 
      cd gkit2light/master_MecaSim/
      doxygen ./Doxyfile
                              
    • Lisez la documentation Doxygen à partir du fichier gkit2light/master_MecaSim/doc/html/index.html
    • Si vous n'arrivez pas à générer la documentation, lisez la page principale
    • Observer le répertoire où se trouvent les données : gkit2light/data/
      • gkit2light/data/textures : pour placer des textures
      • gkit2light/data/CreateMesh : programme pour créer des maillages de tissu ou convertir des fichiers .obj .off en fichiers pour l'application
      • gkit2light/data/drap10 : fichiers de données d'un tissu de 10 * 10 particules
      • gkit2light/data/drap70 : fichiers de données d'un tissu de 70 * 70 particules
      • gkit2light/data/vache : fichiers de données d'une vache
      • gkit2light/data/sphere : fichiers de données d'une sphère
      • gkit2light/data/bunny : fichiers de données du Standford bunny
    • Les répertoires pour les données de la simulation comprennent 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
    • Répertoire pour l'exécution de l'application : gkit2light/master_meca_sim/exec/
      • Fichier_Param.simu : paramètres de la simulation - gravité, viscosité, nb itérations
      • Fichier_Param.objet : paramètres de l'objet simulé - données, k, nu, dt, etc.

    Travail à effectuer - 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/master_MecaSim/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/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/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 ObjetSimuleMSS::initMeshObjet() du fichier ObjetSimule.cpp pour créer le maillage de l'objet simulé.
        • Complétez la fonction ObjetSimuleMSS::updateVertex() du fichier ObjetSimule.cpp pour mettre à jour le maillage de l'objet simulé au cours de la simulation.

        Calcul des forces des ressorts

        • Complétez le code de l'application pour calculer les forces qui sont exercées sur chacune des particules par les ressorts du système masses-ressorts. Il s'agit de la fonction ObjetSimuleMSS::CalculForceSpring() présente dans le fichier CalculsMSS.cpp. Pensez à prendre en compte les forces d'amortissement des ressorts.

        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::CollisionPlan 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.

    Galerie des projets d'étudiants