README.md

-# Site web et ressources de l'UE UE M1if37 Animation en synthèse d'image
+# Site web et ressources de l'UE Apprentissage Profond Et Image
 
-[La page de l'UE est ici](http://alexandre.meyer.pages.univ-lyon1.fr/m1if37-animation/)
+[La page de l'UE est ici](http://alexandre.meyer.pages.univ-lyon1.fr/m2-apprentissage-profond-image/)
 
 
 
 
 ## Explication de la génération
 
-Le site web est désormais fabriqué par ```Hugo``` (thème [congo](https://jpanther.github.io/congo/)). les sources se trouvent dans le répertoire ```web```.
-Le site web est mis à jour par intégration continue (CI/CD) à chaque fois que vous faites un push (rien besoin d'autre, à part attendre quelques secondes). Le script d'intégration continue est ```.gitlab-ci.yml```.  Pour voir le résultat du script de génération, [allez ici](https://forge.univ-lyon1.fr/Alexandre.Meyer/m1if37-animation/-/jobs) ou depuis l'interface dans CI/Jobs.
+Le site web est désormais fabriqué par ```Hugo``` (thème [congo](https://jpanther.github.io/congo/)). les sources se trouvent dans le répertoire ```web```. Le site web est mis à jour par intégration continue (CI/CD) à chaque fois que vous faites un push (rien besoin d'autre, à part attendre quelques secondes). Le script d'intégration continue est ```.gitlab-ci.yml```.  Pour voir le résultat du script de génération, [allez ici](https://forge.univ-lyon1.fr/Alexandre.Meyer/m2-apprentissage-profond-image/-/jobs) ou depuis l'interface dans CI/Jobs.
 
-Le fichier ```site/config.toml``` permet de configurer la génération du site. Mais noramlement il n'y a pas besoin d'y toucher.
+Le fichier ```site/config.toml``` permet de configurer la génération du site. Mais noramlement il n'y a pas besoin d'y toucher sauf pour changer les menus et le titre du site.
    * Les pages web sont générées à partir du répertoire ```web/content```. 
    * La page principale du site est ```web/content/_index.html```. Il faut bien laissé le ```_```, il indique qu'il y a des sous-répertoires 
-   * ```web/content/controle``` pour la partie "Conrtôle d'animation". ```web/content/controle/index.md``` produit la page de cette partie.
-   * ```web/content/personnage``` pour la partie "Animation de personnage virtuel". 
-   * ```web/static``` : les fichiers autres (pdf, images, sujets, etc.) sont à ranger dedans. Par exemple, il y a 
+   * ```web/content/am```: les pages de contenus de la partie AM
+   * ```web/content/jd```: les pages de contenus de la partie JD
+   * ```web/content/nb```: les pages de contenus de la partie NB
+   * ```web/static``` : les fichiers autres (pdf, images, etc.) sont à ranger dedans. Par exemple, il y a 
       * ```web/static/images``` pour les images du site;
       * ```web/static/doc``` documents généraux de l'UE;
-      * ```web/static/doc_controle``` documents de la partie contrôle (NP);
-      * ```web/static/doc_charanim``` documents de la partie personnage (AM);
 
+La doc du générateur "hugo" : [https://gohugo.io/content-management/organization/](https://gohugo.io/content-management/organization/)
 
 
 ## Tester le site en local
@@ -32,5 +31,5 @@ Pour tester vos mises à jour en local :
 Vous pouvez aussi essayer de contruire le site en static en faisant juste ```hugo``` : le site sera constuit dans le répertoire public.
 
 
-Toutes les infos sont détaillées ici !
+### D'autres infos
 Pour convertir du DOKUWIKI en Markdown, on peut utiliser pandoc??? (todo) ou certains web en ligne.
\ No newline at end of file

web/config.toml

-baseURL = "http://alexandre.meyer.pages.univ-lyon1.fr/m1if37-animation/"
-title = "M1if37 Animation en synthèse d'images"
-#theme = "etch"
-#theme = "ucax"
-#theme = "paige"
-#theme = "hugo-flex"
-theme = "congo"
-languageCode = "fr-FR"
-enableInlineShortcodes = true
-pygmentsCodeFences = true
-pygmentsUseClasses = true
-
-publishDir = "public"
-
-
-# [author]
-#   name = "Alexandre Meyer"
-#   image = "img/author.jpg"
-#   headline = "M1if37"
-#   bio = ""
-
-
-[params]
-  description = "Animation en synthèse d'images"
-  copyright = ""
-  dark = "auto"
-  highlight = true
-  mainSections = "personnage;controle;posts"
-  #color = "gray"           # Any color in CSS syntax
-  #width = "52rem"          # Any length in CSS syntax
-  colorScheme = "fire"
-  # footer= ""
-  # rss = "" 
-  article.showDate = false
-
-
-# [[footer]]
-#   name = "Privacy"
-#   url = "https://external-link"
-#   - name: Aboutaaa
-#     url: about/
-#     weight: 1
-
-[menu]
-    [[menu.main]]
-        identifier = "Physique"
-        name = "Physique"
-        title = "Physique"
-        url = "https://perso.liris.cnrs.fr/fzara/Web/M1Animation.html"
-        weight = 1
- 
-    [[menu.main]]
-        identifier = "Personnage"
-        name = "Personnage"
-        title = "Personnage"
-        url = "/personnage/"
-        weight = 2
-
-    [[menu.main]]
-        identifier = "Controle"
-        name = "Controle"
-        title = "Controle"
-        url = "/controle/"
-        weight = 3
-
-  
-[permalinks]
-  posts = "/:title/"
-
-[markup.goldmark.renderer]
-  # Allow HTML in Markdown
-  unsafe = true
-
-  [markup.tableOfContents]
-    ordered = true
-
+baseURL = "http://alexandre.meyer.pages.univ-lyon1.fr/m2-apprentissage-profond-image/"
+title = "Apprentissage et Image"
+#theme = "etch"
+#theme = "ucax"
+#theme = "paige"
+#theme = "hugo-flex"
+theme = "congo"
+languageCode = "fr-FR"
+enableInlineShortcodes = true
+pygmentsCodeFences = true
+pygmentsUseClasses = true
+
+publishDir = "public"
+
+
+# [author]
+#   name = "Alexandre Meyer"
+#   image = "img/author.jpg"
+#   headline = "MLImage"
+#   bio = ""
+
+
+[params]
+  description = "Apprentissage Profond Et Image"
+  copyright = ""
+  dark = "auto"
+  highlight = true
+  mainSections = "personnage;controle;posts"
+  #color = "gray"           # Any color in CSS syntax
+  #width = "52rem"          # Any length in CSS syntax
+  colorScheme = "fire"
+  # footer= ""
+  # rss = "" 
+  article.showDate = false
+
+
+# [[footer]]
+#   name = "Privacy"
+#   url = "https://external-link"
+#   - name: Aboutaaa
+#     url: about/
+#     weight: 1
+
+[menu]
+    [[menu.main]]
+        identifier = "PartieAM"
+        name = "PartieAM"
+        title = "PartieAM"
+        url = "/am/"
+        weight = 1
+ 
+    [[menu.main]]
+        identifier = "PartieJD"
+        name = "PartieJD"
+        title = "PartieJD"
+        url = "/jd/"
+        weight = 2
+
+    [[menu.main]]
+        identifier = "PartieNB"
+        name = "PartieNB"
+        title = "PartieNB"
+        url = "/nb/"
+        weight = 3
+
+  
+[permalinks]
+  posts = "/:title/"
+
+[markup.goldmark.renderer]
+  # Allow HTML in Markdown
+  unsafe = true
+
+  [markup.tableOfContents]
+    ordered = true
+

web/content/_index.md

-# Master 1 Informatique - UE M1if37 Animation en synthèse d'image (3 ECTS)
+# Master 2 ID3D et IA - UE Apprentissage Machine Et Image (3 ECTS)
 
-Responsables de l'enseignement : [Alexandre Meyer](	
-http://liris.cnrs.fr/alexandre.meyer), [Nicolas Pronost](	
-http://liris.cnrs.fr/nicolas.pronost) et [Florence Zara](	
-http://liris.cnrs.fr/florence.zara) - LIRIS, Université Lyon 1
+Responsables de l'enseignement : [Alexandre Meyer](http://liris.cnrs.fr/alexandre.meyer), 
+[Julie Digne](http://liris.cnrs.fr/jule.digne) 
+et [Nicolas Bonneel](http://liris.cnrs.fr/nicolas.bonneel) - LIRIS, Université Lyon 1
 
-Volume horaire : 10h30 CM, 19h30 TP
+Volume horaire : 30h (CM/TP)
 
 
-![im_all.png](images/im_all.png)
+![MLImage_all.jpg](images/MLImage_all.jpg)
 
 ## Objectif de l'UE
-<p style="text-align:justify;">M1if37 est une UE optionnelle de la 1è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.</p>
+<p style="text-align:justify;">Il s'agit d'une UE optionnelle de la 2ère année du Master d'Informatique parcours IA et ID3D de l'Université Lyon 1. Les cours ont lieu au semestre 1 (automne). L'objectif de l'UE est de donner les bases en apprentissage machine (notamment apprentissage profond) pour les problèmes d'images. Le cours présentera d'abord les problèmes classiques liés à l’image comme la classification, l'extraction d'informations, la reconnaissance de formes, le suivi, la segmentation, etc. Un large panel des différents types de réseaux (CNN, auto-encoder, LTSM, GAN, etc.) sera donné, ainsi que leurs applications à des problèmes élaborés allant de l’édition (super-résolution, transfert de motifs, de palettes) jusqu’aux méthodes génératives (génération de visages, de maillage, d’animations, de textures, etc.) plus ou moins guidé par l’utilisateur.
+</p>
 
-[Les slides de la présentation des options sont ici.](doc/M1if37_PresOption.pdf)
+[Les slides de la présentation des options sont ici.](doc/MLImage_PresOption.pdf)
 
 
 ## Thématiques abordées
 
-### Animation par modèles physiques (F. Zara) - 4h30 CM, 6h30 TP
-  * Concepts physiques (forces, lois de Newton)
-  * Méthodes d'intégration numérique
-  * [La page web de cette partie](https://perso.liris.cnrs.fr/fzara/Web/M1Animation.html)
+### Deep learning et images (A. Meyer)
+  * Les bases de l'apprentissage profond : espace latent, régularisation, etc.
+  * CNN, Autoencodeur
+  * Segmentation : U-Net
+  * Tracking : YOLO
+  * Capture du squelette (type OpenPose, XNect, etc.)
+  * Notion de transformer/attention pour la reconnaissance
 
+### Deep learning génératif et deep learning géometrique (J. Digne)
+  * Génération d'images: GANs et Réseaux de diffusion
+  * Apprentissage pour les données géometriques:
+     * Nuages de points (pointNet, etc.)
+     * Maillages (MeshConv, etc.)
+     * Diffusion sur les surfaces
+  * Représentations neuronales implicites (IGR, SIREN)
+  * Champs de radiance neuronaux (Nerf)
 
-### Animation de personnage (A. Meyer) - 4h30 CM, 6h30 TP
-  * Animation basée squelette
-  * Déformation de maillage (skinning)
-  * [La page web de cette partie](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=charanim_m1#master_1_informatique_-_ue_m1if37_animation_en_synthese_d_image)
 
+### Transport optimal (N. Bonneel)
+  * Introduction au transport optimal
+  * ...
 
-### Contrôle de mouvement (Nicolas Pronost) - 1h30 CM, 6h30 TP
-  * Mouvement d'objets rigides articulés
-  * [La page web de cette partie](controle)
 
 
 ## Emploi du temps 2023
 
-![documents/M1if37_edt.png](doc/M1if37_edt.png)
+Les cours sont le Jeudi après-midi entre octobre et fin janvier.
+L'edt détaillé doit encore être finalisé ...
 
-  * Cours en salle TD10 Nautibus
-
-  * TP en salles TP11, TP12 Nautibus
 
 ## Modalités de contrôle des connaissances (MCC)
-   * **1 note de CCF** portant sur les 3 parties du cours
-   * **3 notes de TP** : TP F. Zara, TP A. Meyer, TP N. Pronost (code + rapport + démo ou vidéo)
-
-   * **Dates des évaluations** : 
-     * Examen écrit : mercredi 24 mai 2023 8h-9h30 en C3
-     * Démo de TP : mercredi 24 mai 2023, de 9h45 à 12h en TP11, TP12
-     * Date limite de rendu des 3 archives : mercredi 24 mai 2023 12h
-
-  * **Modalité de rendu des TPs :** <p style="text-align:justify;">
-     * Une archive sera à déposer sur TOMUSS (dans les 3 colonnes correspondantes). Cette archive contiendra le code du TP + un rapport.
-     * Nous vous demandons également de mettre dans les 3 autres colonnes correspondantes de TOMUSS, l'URL pour accéder à une vidéo de votre projet, si vous ne faites pas de démo (car nous ne le compilerons pas forcément, donc il faut montrer tout votre travail).</p>
-
+TBA

web/content/am/TP_AEAnimation_oldTP.md

+==== Partie (III) Animation et DL ====
+
+Une vidéo courte expliquant quelques principes pour le TP :
+
+<iframe width="560" height="315" src="//www.youtube.com/embed/ZXjhquKAfVs" frameborder="0" allowfullscreen></iframe>
+
+  
+  
+
+[Fast Neural Style Transfer for Motion
+Data](http://www.ipab.inf.ed.ac.uk/cgvu/cga2017.pdf), Holden etal, 2017.
+Le papier qui propose une approche équivalente pour transférer le style
+d'une animation vers une autre. Le contenu est le geste et le style est
+l'effet donné dans le geste en relation avec l'état émotionnel, la
+personnalité ou les caractéristiques physiques particulières (ages,
+force, etc.). Ce Tp se propose de coder une version simplifiée de ce
+papier. Nous ferons, comme pour les images précédemment, une
+optimisation. Le papier original propose d'entrainer un réseau à faire
+ce travail, ce qui serait plus efficace une fois le réseau entrainé mais
+qui demanderait plusieurs heures de calculs. Pour ce TP l'optimisation
+ne prendra que quelques minutes, mais ne fournira un transfert qu'entre
+2 animations.
+
+  
+  
+
+-   [Le code de départ est à télécharger
+    ici.](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/download/StyleTransfer.zip)
+
+<!-- -->
+
+-   Il faut installer un peu plus de lib que pour pytorch. Panda3D,
+    pyglm, etc. sont nécessaires pour la visualisation des animations.
+    Vous pouvez sûrement pouvoir installer un env avec le fichier .yml
+    fournit
+
+<!-- -->
+
+    conda env create -f environment.yml
+
+Ou alors un environnement neuf :
+
+    conda create --name py-deepan python=3.8
+    conda activate py-deepan
+
+    conda install numpy
+    conda install pillow
+    conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch    (mais allez voir la page de pytorch)
+    conda install multipledispatch
+    pip install panda3d                   (==1.10.7)
+    pip install torchsummary
+    pip install PyGLM
+
+  
+
+     * Vous devez installer le code comme un package pour que les 'import' trouve les fichiers :
+
+    cd ....StyleTransfer
+    pip install -e .
+
+  
+
+     * En cas de problème pour trouver les données=le chemin vers data (et seulement en cas de problème). Il faut modifier dans pydeepan/__init__.py la variable tout à la fin après le dernier "else":
+
+    else:
+       dir_resources = dir_pydeepan+"/data"                      # mettez le chemin absolu???
+
+  
+
+-   Le programme principal à lancer est
+    **pydeepan/demo/StyleTransferDemo.py**.
+
+<!-- -->
+
+       * 'z' (dés)active l'animation
+       * 'n' : joue la frame suivante d'une animation
+       * 'b' : joue la frame précédente d'une animation
+       * 'p' : passe aux animations suivantes (en restant dans le même dataset)
+       * 'd' : change de dataset (il y en a deux : StyleTransfer et Emilya)
+       * 'l' : lance l'optimisation sur les longueurs de membres
+       * 'e' : passe les animations dans l'auto-encodeur
+       * 't' : transfert le style d'une animation vers une autre (le code est à compléter)
+
+  
+
+-   Une animation est représentée par un tableau de 240 frames x 73
+    valeurs. Voir le fichier HPAAnimation.py pour une description
+    détaillée des 73 valeurs. Dans ce TP nous n'utilisons que les
+    valeurs de 0 à 65 qui représentent les positions 3D de chaque
+    articulation. Il n'y a pas de notion d'angles dans ce format
+    d'animations. Déplacer une articulation revient souvent à changer la
+    longueur d'un membre. Il y a une optimisation (touche 'l' et class
+    AOSkeletonConstraint.py) qui effectue une descente de gradient
+    (pytorch) pour "remettre" les longueurs de membre aux valeurs
+    initiales.
+
+  
+
+-   Remarque : l'autoencoder de ce code est très basique. Il introduit
+    des tremblements pour certaines animations. Il y a surement moyen de
+    faire mieux.
+
+  
+  
+
+##### Tester l'auto-encodeur
+
+Ajouter une action liée à la touche 'r' qui "casse" une animation pour
+une ou deux articulations (par exemple figer épaule+coude). Puis vous
+pourrez tester le passage dans l'auto-encoder avec la touche 'e'
+(e=encodeur). Testez également l'optimisation sur les longueurs de
+membres. Regardez dans le fichier "HPAAnimation.py" pour une description
+des articulations.
+
+          # 42 = coord X de l'épaule gauche. ':' signifie toutes les valeurs. np.mean calcule la moyenne.
+          self.anims[:,42] = np.mean( self.anims[:,42] )+ 2   
+
+Vous pouvez également ajouter de l'aléatoire sur certaines
+articulations. Pas sur toutes en même temps, l'auto-encodeur n'est pas
+si fort.
+
+  
+  
+
+##### Interpolation dans l'espace caché (espace latent)
+
+-   Faites l'interpolation entre l'animation 1 et l'animation 2 dans
+    l'espace 3D, ranger le résultat dans l'animation 3.
+-   Faites l'interpolation entre l'animation 1 et l'animation 2 dans
+    l'espace latent (l'espace de l'ato-encodeur), ranger le résultat
+    dans l'animation 4.
+
+<!-- -->
+
+-   Comparez les 2 résultats.
+
+  
+
+##### Transfert de style
+
+Comme pour les images, l'objectif est de produire une nouvelle animation
+par optimisation de toutes les positions pour toutes les frames. Donc
+d'optimiser les 240x73 valeurs. Le code à trou réalisant l'optimisation
+pour transférer le style est dans **pydeepan/chara/AOStyleTransfer.py**.
+Vous devez compléter les fonctions 'optimize', 'loss' et 'gram'.
+
+  
+
+-   Essayer déjà de partir d'un tableau/animation random est d'optimiser
+    pour produire une animation ayant le même code que l'animation
+    source (sans s'occuper du style). Dans la fonction 'loss', encoder
+    les deux animations et l'erreur sera la différence au carré des deux
+    codes. Il faut jouer sur le 'learning rate'. A la fin, vous obtenez
+    deux animations très différentes mais qui ont le même code. Un
+    passage dans l'auto-encodeur réduit fortement les différences.
+
+  
+
+-   Ajouter maintenant les infos de style de la 2e animation source dans
+    la fonction 'loss'.
+
+  
+  
+  
+
+## Quelques lectures
+
+  
+
+     * [[http://courty.fr/deep-learning-02-etapes-dun-projet-de-deep-learning/|
+
+Une bonne explication de toutes les étapes nécessaire à un apprentissage
+sont décrites ici.\]\]
+
+  
+Classification d'images avec PyTorch
+
+     * [[https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html|Sur CIFAR pour coder la base]]
+
+  
+Pour aller plus loin :
+
+     * [[https://medium.com/@shun.bu/a-diagrammatic-summary-of-the-deep-learning-architectures-for-computer-vision-applications-cd1ec193d8dc|A diagrammatic summary of the deep learning architectures for computer vision applications ]]
+     * Un article de recherche : [[https://arxiv.org/abs/1409.1556|Very Deep Convolutional Networks for Large-Scale Image Recognition]]
+
+  
+  
+Reconnaissance de caractères
+
+     * [[https://towardsdatascience.com/tutorial-alphabet-recognition-deeplearning-opencv-97e697b8fb86|Un tutoriel décrivant les étapes pour la reconnaissance de caractères]].
+     * [[https://github.com/gaurav0651/emnist/blob/master/train_emnist.ipynb|Un exemple de code PyTorch de reconnaissance de caractères]].

web/content/am/TP_Classification.md

+**ATTENTION DRAFT**
+
+
+# Partie (I.a) Classification de points 2D
+
+Un réseau de neurones est un très bon 'classifier'. Dans un exemple simple, nous voudrions reconnaitre la classe d'un point à partir de ses coordonnées 2D notées (x_1, x_2). Un point peut appartenir à 2 classes : classe 1 par exemple en bleu ou classe 2 par exemple en vert. Le réseau prend en entrée 2 valeurs (x_1, x_2) et sort 2 valeurs (suis-je_bleu?, suis-je_vert?). "suis-je_bleu?" sera représenté par un nombre réel entre 0 et 1 : proche de 0 indiquant que le point n’appartient pas à la classe, proche de 1 indiquant que le point appartient à la classe. Par exemple, une sortie \[0.3, 0.7\] sera tranché en "c'est un point de la classe 2".
+
+  
+L'entrainement du réseau consistera à lui montrer toute une série de coordonnées de points avec les valeurs de classes associées. Le réseau va optimiser ses paramètres (poids) pour que le taux d'erreur devienne le plus petit possible.
+
+  
+
+## Un neurone
+
+Un neurone artificiel (ou un perceptron) reçoit des valeurs d’entrées, il les multiplie une à une par un poids, puis en fait la somme. Cette
+somme est passée à une fonction d'activation. Par exemple une fonction d'activation très simple peut-être de comparer la somme à un seuil. Si
+elle est inférieure, la valeur de sortie sera 0, 1 sinon. L’objectif de l’apprentissage/optimisation est de retrouver les poids qui ferons correspondre au mieux la sortie à partir des entrées sur une base de connaissance disponible.
+
+<img src="//neurone.png" class="align-center" width="400" />
+
+  
+
+## Un réseau
+
+Le principe du réseau de neurones est d’assembler entre-eux des neurones, pour leur faire apprendre des tâches complexes. Les neurones
+vont être regroupés en couches, une couche réalisant une tâche donnant un niveau d’abstraction supplémentaire pour la couche suivante. Par
+exemple, pour reconnaître une lettre, la couche la plus basse va repérer des morceaux de courbes et la couche supérieure estime que certaines
+courbes ensembles forme un 'A' et non un 'S'. L’utilisation de plusieurs couches (layer en anglais) est appelée apprentissage profond/Deep Learning. <img src="//dl_layer.png" class="align-center" width="400" />
+
+  
+[Voir une explication plus détaillé sur Wikipedia par exemple.](https://fr.wikipedia.org/wiki/R%C3%A9seau_de_neurones_artificiels)
+
+  
+Dans un 1er temps, allez jouer sur le web avec ["Playground classifier"](https://playground.tensorflow.org/) pour comprendre le principe de la classification de points avec un réseau de neurones profond.
+
+  
+<img src="//playground_dl.jpg" class="align-center" width="500" />
+
+  
+  
+Dans un 2e temps vous allez écrire votre classifier de points avec PyTorch.
+
+  
+  
+
+  
+  
+
+#### Les données
+
+Pour notre problème de reconnaitre la couleur d'un point, il faut des données d'apprentissage. [Le code de départ est donné ici](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/classifier/classifier_pointcloud_empty.py).
+Ce code génère des points (les données) procéduralement, donc autant que l'on veut. La classe bleu sont les points dont les coordonnées sont inférieures à cosinus, et la classe verte sont les points au dessus de cosinus. Dans un "vrai" problème, ces données ne peuvent se générer, il faut les trouver quelque part ...
+
+<img src="//point_cloud.jpg" class="align-center" width="400" />
+
+  
+  
+** L'apprentissage **
+
+L'apprentissage se passe en différentes phases.
+* La définition du réseau.
+* La configuration de l'optimisation (optimizer), en général [[https://fr.wikipedia.org/wiki/Algorithme_du_gradient_stochastique Stochastic Gradient Descent]] couplé à une fonction d'erreur.
+* La phase d'entrainement optimise les poids de chaque neurone à partir des données d'entrée couplées à leur sortie. La fonction d'erreur sert de mesure à faire descendre.
+* Une phase d'évaluation **avec des données que le réseau n'a jamais vu** pour mesurer la qualité de l'apprentissage.
+
+Le code ci-dessous donne un réseau minimaliste. Vous devrez l'améliorer pour qu'il soit plus efficace.
+```
+      # voir le code de départ : https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/classifier/classifier_pointcloud_empty.py
+
+        ########################################################################################"
+        # Copier/coller juste avant main
+        class Net(nn.Module):
+           def __init__(self):
+               super(Net, self).__init__()
+               self.fc1 = nn.Linear(2, 64)
+               self.fc2 = nn.Linear(64, 2)
+
+           def forward(self, x):
+              x = F.relu(self.fc1(x))
+              x = self.fc2(x)
+              return x
+
+
+
+        ########################################################################################"
+        ############# NETWORK definition/configuration => à copier/coller dans le main 
+        net = Net()
+        print(net)
+
+        ############# SGD config: Stochastic Gradient Descent Config
+        criterion = nn.CrossEntropyLoss()
+        optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+        ############ TRAINNING
+        for epoch in range(5):  # loop over the dataset multiple times
+            running_loss = 0.0
+            for i in range(1000):         # iterate on mini batches. mani-batch = a subset of the database
+                inputs, labels = next_batch(128)
+                inputs = torch.from_numpy(inputs)
+                labels = torch.from_numpy(labels).long()
+               
+                # zero the parameter gradients
+                optimizer.zero_grad()
+        
+                # forward + backward + optimize
+                outputs = net(inputs)
+                loss = criterion(outputs, torch.max(labels, 1)[1] )
+                loss.backward()
+                optimizer.step()
+
+                # print statistics
+                running_loss += loss.item()
+                if i % 100 == 99:    # print every 2000 mini-batches
+                    print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
+                    running_loss = 0.0      
+
+
+        ############ EVALUATION         
+        TODO
+        
+        ############ DRAWING POINT CLOUD WITH ERROR
+        TODO
+```
+
+[Regardez la page des tutos de PyTorch](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py).
+
+  
+  
+
+#### Le résultat
+
+Le résultat sera le taux de bonne reconnaissance de points, mesuré avec des points jamais observés pendant l'apprentissage. Par exemple après un apprentissage nous obtenons un taux de 96% de bonne classification, les points rouges sur l'image suivante sont les points mal classifiés.
+
+<img src="//point_cloud_errorclassif.jpg" class="align-center" width="400" />
+
+  
+  
+Pour rendre le problème un peu plus dur vous pouvez augmenter la plage de génération des points en changeant ceci :
+```
+    x = np.array( [ 2.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
+    devient
+    x = np.array( [ 4.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
+```
+
+<img src="//point_cloud_4pi.jpg" class="align-center" width="400" />  
+  
+  
+
+
+
+# Partie (I.b) Classification d'images
+
+Pour ce 2e problème un peu plus concret, nous disposons d'images et nous voudrions reconnaitre la classe à laquelle elles appartiennent. Par
+exemple, pour reconnaitre le nombre à partir de l'image du nombre écrit ou reconnaitre la figure géométrique à partir d'un dessin, ou plus largement reconnaitre une famille d'objets (chat, voiture, avion, fourchette, etc.).
+
+  
+Pour ce type de tâche , le réseau approprié est le ConvNET ou CNN : Convolution Neural Network. Vous pouvez lire des explications sur ce qu'est un CNN :
+
+     * [[https://medium.com/@CharlesCrouspeyre/comment-les-r%C3%A9seaux-de-neurones-%C3%A0-convolution-fonctionnent-b288519dbcf8|Plutôt vulgarisation]]
+     * [[https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/|Explication intuitive]]
+
+<img src="/convnet.png" class="align-center" width="600" />
+
+  
+Pour ce TP, nous vous invitons à utiliser [une base de données d'images issue d'un projet de L3 qui cherche à reconnaitre 5 formes dessinés](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/data/shapes5_preprocessed.zip) : carré, cercle, triangle, sablier, étoile. Il y a que quelques centaines d'images par forme, c'est un bon challenge de voir ce que la reconnaissance donne avec finalement assez peu d'images. Il est également intéressant d'augmenter les données. Dans le cas d'images comme ici, vous pouvez faire de petites rotations aléatoires aux images pour en augmenter le nombre.
+
+  
+Il est également possible d'utiliser différentes base de données plus classiques :
+* MNIST : un base de donnée de chiffre manuscrits
+* la base de données de caractères [[https://www.nist.gov/itl/iad/image-group/emnist-dataset|EMNIST]]. Elle est disponible également [[https://s3.amazonaws.com/nist-srd/SD19/by_merge.zip|ici avec les images rangées dans un répertoire dont le nom est le code ascii en hexa]]. 
+* Toutes les bases classiques de reconnaissance de catégorie d'images: [[https://www.cs.toronto.edu/~kriz/cifar.html|CIFAR-10 ou CIFAR-100]]
+* Un peu plus de challenge avec "[[https://www.kaggle.com/c/quickdraw-doodle-recognition/data|quickdraw-doodle-recognition]]" : une base de dessins manuels à reconnaitre, 300 classes, 73 Go de données vectoriels et $12000 de récompense ...
+
+  
+  
+Un exemple de code qui charge une base d'images, voir également la doc de [imagefolder](https://pytorch.org/docs/stable/torchvision/datasets.html#imagefolder) et de [DataLoader](https://pytorch.org/docs/stable/data.html#) :
+```
+    from torchvision import datasets, transforms
+    from torch.autograd import Variable
+    import torchvision
+    from torchvision.datasets import ImageFolder
+    from torch.utils.data import DataLoader
+    from torchvision.transforms import ToTensor
+    from torch.utils.data.sampler import SubsetRandomSampler
+
+
+    class MyTransform(object):    # Votre propre fonction de transfo d'images utilisée en preprocessing
+        def __call__(self, x):
+            y = preprocess(x)
+            return y
+
+
+
+    def imshow(img):              # Pour afficher une image
+        plt.figure(1)
+        img = img / 2.0 + 0.5     # unnormalize
+        npimg = img.numpy()
+        plt.imshow(np.transpose(npimg, (1, 2, 0)))
+        #plt.imshow(npimg)
+        plt.show()
+
+
+            
+        TRANSFORM_IMG = transforms.Compose([
+                MyTransform(),    # Votre propre fonction de transfo d'images utilisée en preprocessing
+                transforms.Resize(16),
+                #transforms.CenterCrop(256),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0., 0., 0.],
+                                     std=[0.5, 0.5, 0.5] )
+                ])
+        mydata = ImageFolder(root="../data/shapes5_preprocessed", transform=TRANSFORM_IMG)
+        loader = DataLoader(mydata, batch_size=32, shuffle=True, num_workers=2)
+
+```
+  
+
+* [[https://github.com/ncullen93/torchsample/blob/master/examples/Transforms%20with%20Pytorch%20and%20Torchsample.ipynb|Un très bon tutoriel sur le chargement de données avec PyTorch]]
+
+  
+  
+Il est intéressant de voir que chaque couche de convolutions devient de plus en plus spécifiques à l'objet :
+<img src="//dl_cnn_progression.png" class="align-center" width="600" />  

web/content/am/TP_Installation.md

+
+# Installation
+
+
+## Installation de tous les outils de dév en local
+
+Faites les installations de [Anaconda, Numpy, MatPlotlib et PyTorch décrites ici](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples). Anaconda est un gestionnaire d’environnements Python. Il vous permet entre autre d'avoir plusieurs installations de Python avec des packages différents sans interférence entre chaque environnement. Si vous avez
+besoin d'un turorial décrivant l'installation de chaque étape en détails, [regardez ici](https://mrmint.fr/installer-environnement-python-machine-learning-anaconda).
+
+  
+  
+Sous windwos lancez "Anaconda navigator" puis lancer une console. Sous Linux, depuis un terminal lancer ```conda activate p36```
+
+  
+Votre code va être écrit en Python. Vous pouvez utiliser par exemple [l'IDE Spyder](https://www.spyder-ide.org/) qui s'installe avec
+Anaconda, ou autre comme [PyCharm](https://www.jetbrains.com/pycharm/) qui est gratuit pour les étudiants. Éventuellement écrire votre dans un éditeur de code puis lancer votre script comme ceci :
+``` python mon_prog.py```
+
+
+
+  
+## Colab
+
+Ou vous pouvez travailler avec
+[Colab/Google](https://colab.research.google.com/). Vous trouverez [un tutoriel ici sur medium](https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d). Colab permet d'écrire et exécuter du code en ligne, possibilité de le
+faire tourner gratuitement sur une Nvidia K80.

web/content/am/TP_Style.md

+  
+
+
+# Partie (II) Une application pratique des réseaux : transfert de style entre images
+
+  
+Ce TP vise à implémenter avec PyTorch le transfert de style d'une image à une autre en suivant un papier de Gatys etal présenté à CVPR 2016 :
+[Image Style Transfer Using Convolutional Neural Networks](https://www.cv-foundation.org/openaccess/content_cvpr_2016/html/Gatys_Image_Style_Transfer_CVPR_2016_paper.html). Ce n'est pas foncièrement un papier de deep learning et dispose de
+nombreux atouts pour un TP en image : utilisation d'un réseau pré-entrainé comme un outil, utilisation du framework de DL/PyTorch pour l'optimisation, code compact et résultats visuels et "rigolo".
+
+  
+[Le code vide peut se trouver ici](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/style_transfer/StyleTransfer_empty.py).
+
+*   [une image de contenu](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/master/src/style_transfer/images/montagne_small.jpg)
+*   [une image de style](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/master/src/style_transfer/images/peinture1_small.jpg)
+
+Le programme commence par 3 fonctions pour charger et convertir une image :
+* //load_image// pour redimensionner et normaliser avec la moyenne/écart type de VGG19; 
+* //im_convert// de conversion d'un Tensor en une image Numpy ;
+* imshow pour visualiser une image sortant de //im_convert//.
+
+```
+    from PIL import Image
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    import torch
+    import torch.optim as optim
+    from torchvision import transforms, models
+
+
+
+    def load_image(img_path, max_size=400, shape=None):
+        ''' Load in and transform an image, making sure the image is <= 400 pixels in the x-y dims.'''
+        
+        image = Image.open(img_path).convert('RGB')
+        
+        # large images will slow down processing
+        if max(image.size) > max_size:
+            size = max_size
+        else:
+            size = max(image.size)
+        
+        if shape is not None:
+            size = shape
+            
+        in_transform = transforms.Compose([
+                            transforms.Resize(size),
+                            transforms.ToTensor(),
+                            transforms.Normalize((0.485, 0.456, 0.406), 
+                                                 (0.229, 0.224, 0.225))])
+
+        # discard the transparent, alpha channel (that's the :3) and add the batch dimension
+        image = in_transform(image)[:3,:,:].unsqueeze(0)
+        
+        return image
+
+
+
+    # helper function for un-normalizing an image and converting it from a Tensor image to a NumPy image for display
+    def im_convert(tensor):
+        image = tensor.to("cpu").clone().detach()
+        image = image.numpy().squeeze()
+        image = image.transpose(1,2,0)
+        image = image * np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406))
+        image = image.clip(0, 1)
+        return image
+
+
+    def imshow(img):              # Pour afficher une image
+        plt.figure(1)
+        plt.imshow(img)
+        plt.show()
+
+
+    if __name__ == '__main__':
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        #device = torch.device("cpu")
+        print(device)
+
+        ########################## DISPLAY IMAGE#########################################################""
+        content = load_image('images/mer.jpg').to(device)
+        style = load_image('images/peinture1.jpg', shape=content.shape[-2:]).to(device)
+
+        imshow(im_convert(content))
+        imshow(im_convert(style))
+```
+  
+  
+Nous allons réutiliser un réseau VGG déjà entrainé. [VGG est un réseau qui combine les convolutions afin d'être efficace pour de la reconnaissance d'images](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) (ImageNet Challenge). Quand nous allons optimiser le transfert de style, nous ne voulons plus optimiser les couches du réseau VGG. Ceci se réalise en passant à False le besoin en gradient des paramètres. Vous pouvez donc charger le réseaux avec PyTorch comme ceci, neutraliser les couches et afficher toutes les couches comme ceci :  
+```
+        vgg = models.vgg19(pretrained=True).features
+
+        # freeze all VGG parameters since we're only optimizing the target image
+        for param in vgg.parameters():
+            param.requires_grad_(False)
+
+        features = list(vgg)[:23]
+        for i,layer in enumerate(features):
+            print(i,"   ",layer)
+```
+  
+  
+
+Pour récupérer les caractéristiques intermédiaires d'une image qui passe dans un réseau VGG vous pouvez le faire comme ceci :
+```
+### Run an image forward through a model and get the features for a set of layers. 'model' is supposed to be vgg19
+def get_features(image, model, layers=None):  
+    if layers is None:
+        layers = {'0': 'conv0',
+                  '5': 'conv5', 
+                  '10': 'conv10', 
+                  '19': 'conv19',   ## content representation
+                  }
+        
+    features = {}
+    x = image
+    # model._modules is a dictionary holding each module in the model
+    for name, layer in model._modules.items():
+        x = layer(x)
+        if name in layers:
+            features[layers[name]] = x
+            
+    return features
+```
+  
+  
+Nous allons maintenant créer l'image cible qui va être une copie de l'image de contenu et dont les pixels seront à optimiser :
+```
+        target = content.clone().requires_grad_(True).to(device)
+```
+  
+  
+
+Vous devez écrire la fonction *gram_matrix* qui calcule la [matrice de Gram](https://en.wikipedia.org/wiki/Gramian_matrix) à partir d'un
+tensor. Vous pouvez regarder la documentation de la fonction [torch.mm](https://pytorch.org/docs/stable/torch.html#torch.mm) qui
+multiplie deux matrices, et la fonction [torch.transpose](https://pytorch.org/docs/stable/torch.html#torch.transpose).
+La fonction [torch.Tensor.view](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view) permet de changer la "vue" pour par exemple passer d'un tenseur 2D à un tenseur 1D, ou d'un 3D vers un 2D, etc.
+```
+    def gram_matrix(tensor):
+       # tensor: Nfeatures x H x W ==> M = Nfeatures x Npixels with Npixel=HxW
+       ...
+       return gram
+```
+  
+  
+Écrivez le calcul de coût pour le contenu. Vous pouvez utiliser \[\[\|torch.mean\]\] avec les features extraits de la couche 'conv19'
+qui d'après l'article correspondent globalement au contenu. Attention, les noms de couches ne correspondent pas à l'article.
+
+  
+Écrivez le calcul du coût pour le style. Il va se calculer de la même manière mais vous allez itérer sur les features des autres couches. A tester un peu par essai/erreur (ou regardez l'article).
+
+  
+Le coût total (celui qui sera optimisé) se calcule en faisant la moyenne pondérée entre le coût de style et le coût de contenu. A tester un peu par essai/erreur (ou regardez l'article).
+
+  
+La partie optimisation va donc ressembler à ceci.
+```
+        optimizer = optim.Adam([target], lr=0.003)
+        for i in range(50):
+        
+            # get the features from your target image
+        
+            # the content loss
+        
+            # the style loss
+            
+            # calculate the *total* loss
+        
+            # update your target image
+            optimizer.zero_grad()
+            total_loss.backward()
+            optimizer.step()
+```
+  
+  
+
+## Pour aller plus loin sur le transfert de style entre images
+
+[Un blog qui décrit bien les évolutions de la recherche après l'approche de Gatys](https://dudeperf3ct.github.io/style/transfer/2018/12/23/Magic-of-Style-Transfer/). Donne des explications également autour des approches de normalisation, AdaIN.
+
+  
+  
+  

web/content/am/index.md

+
+---
+title: ""
+description: "Partie A. Meyer"
+---
+
+
+
+
+
+# Les base du Deep Learning pour l'image
+  * [Alexandre Meyer](https://perso.liris.cnrs.fr/alexandre.meyer)
+  * [L'ancienne page de cette partie](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=image_deeplearning)
+
+
+  
+
+## Le Cours
+
+-   \*\* [Les transparents du cours](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/aPDF_COURS_M2/M2_6_DeepLearning_Images.pdf)
+    \*\*
+
+  
+
+<!---
+-   La vidéo du CM de la 1ère partie : TODO
+-   La vidéo du CM de la 2e partie
+<iframe width="560" height="315" src="//www.youtube.com/embed/ge7V2C7eVWk" frameborder="0" allowfullscreen></iframe>
+-->
+  
+  
+  
+
+## Les TP
+1. [Installation](TP_Installation)
+2. [Partie Classification](TP_Classification)
+3. [Partie transfert de style](TP_Style)
+

web/content/controle/index.md

-# Master 1 Informatique - UE M1if37 Animation en synthèse d'image (3 ECTS)
-
-## Contrôle de mouvement
-
-Télécharger [les transparents du cours](../doc_controle/M1IF37_CM_CONTROLEUR.pdf)
-
-
-Télécharger [l'énoncé du TP](../doc_controle/M1IF37_TP_CONTROLEUR.pdf)
-
-
-Accéder [aux ressources pour le TP](../doc_controle/tp.zip)
-
-
-Télécharger [le modèle pour le rapport](../doc_controle/M1IF37_TP_CONTROLEUR-modele_rapport.docx)		
\ No newline at end of file

web/content/jd/_index.md

+
+---
+title: ""
+description: "Partie J. Digne"
+---
+
+
+
+# Partie de Julie Digne 

web/content/nb/_index.md

+
+---
+title: ""
+description: "Partie N. Bonneel"
+---
+
+
+
+# Partie de N. Bonneel

web/content/personnage/_index.md

-
----
-title: ""
-description: "Partie Animation de personnage"
----
-
-
-
-# Partie Animation de personnage
-  * Alexandre Meyer
-  * 4h30 CM, 6h30 TP
-  * [L'ancienne page de cette partie](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=charanim_m1#master_1_informatique_-_ue_m1if37_animation_en_synthese_d_image)
-
-![](../doc_charanim/charanim_tpose.jpg)
-
-
-
-
-## Cours
-  * [Systèmes articulés : cinématique directe](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/aPDF_COURS_M1/M1_1_SkeletonBasedAnimation.pdf)
-  * [Edition d'animations, Graphe d'animations](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/aPDF_COURS_M1/M1_2_MotionControlAndEditing.pdf)
-  * [Capture de mouvements](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/aPDF_COURS_M1/M1_3_MotionCapture.pdf)
-
-
-## Les vidéos des 3 CM (2020)
-[Les vidéos](video)
-
-
-
-## Le TP
-  * [TP animation de personnage virtuel](tp)
-  * [[master_charanim_code|Le code initial]]
-
-#### Rendu
-Les archives sont à rendre sur TOMUSS
-  * TP Animation de personnage virtuel
-    * vous devez rendre une archive avec un readme.txt ou readme.md expliquant ce que vous avez fait et comment lancer le programme
-    * une VIDEO de DEMO ou une démo en LIVE
-  * Barème "Personnage" 
-    * (5 points) TP 1ère partie : affichage d'une animation BVH
-    * (3 points) Contrôleur d'animation :  la base (pilotage au clavier d'un déplacement)
-    * Machine à état (4 points maximum)
-      * basique : pour une machine à état de base avec 4 animations : iddle, marcher, courir, sauter ou kick
-      * avancé : une machine à état plus complète avec de nombreuses animations (une dizaine) : voir celles du répertoire motionGraph_second_life, etc.
-    * Motion Graphe (6 points max)
-      * basique : transition vers un autre animation en cherchant à la volée une transition compatible
-      * avancé : un motion graph construit automatiquement en pré-calcul (voir la fin de l'énoncé qui pointe vers un complément de sujet).
-    * (3 points) Interpolation entre 2 frames, à utilise pour les transitions ou pour une bonne gestion du temps
-    * (1 points) Collision entre personnage et sphères (voir le code PhysicalWorld)
-    * (1 points) bonus de qualité/cohérence de la scène
-    * Le total fait plus que 20 car les points FSM/graphe d'animation sont à comprendre avec un OU : la machine à état rapporte moins de points, car bien moins difficile.

web/content/personnage/tp.md

-  
-
-# TP d'Animation de personnage (M1)
-
-  
-  
-
-## TP partie 1 : affichage
-
-![](/charanim_interpolation.png)  
-Vous allez créer un module Skeleton.h/.cpp (ce code n'est qu'indicatif, vous êtes libre de vos structures de données). Cette classe va stocker un tableau de toutes les articulations (SkeletonJoint) du squelette et pour chaque articulation stocke l'identifiant de l'articulation parent et la matrice de passage de l'articulation vers le monde.
-
-Le fichier est déjà présent dans le code départ avec des TODO à compléter :
-
-``` 
-
-class Skeleton
-{
-public:
-
-   struct SkeletonJoint
-   {
-      int m_parentId;    // Le numéro du père dans le tableau de CAJoint de CASkeleton
-      Transform m_l2w;  // La matrice passant du repère de l'articulation vers le monde
-   };
-
-   Skeleton() {}
-
-   //! Créer un squelette ayant la même structure que définit dans le BVH c'est à dire
-   //! creer le tableau de SkeletonJoint à la bonne taille, avec les parentId initialsé pour chaque case
-   void init(const BVH& bvh);
-
-   //! Renvoie la position de l'articulation i en multipliant le m_l2w par le Point(0,0,0)
-   Point getJointPosition(int i) const;
-
-   //! Renvoie l'identifiant de l'articulation père de l'articulation numéro i
-   int getParentId(const int i) const;
-   
-   //! Renvoie le nombre d'articulation
-   int numberOfJoint() const;
-
-   //! Positionne ce squelette dans la position n du BVH. 
-   //! Assez proche de la fonction récursive (question 1), mais range la matrice (Transform)
-   //! dans la case du tableau. Pour obtenir la matrice allant de l'articulation local vers le monde,
-   //! il faut multiplier la matrice allant de l'articulation vers son père à la matrice du père allant de
-   //! l'articulation du père vers le monde.
-   void setPose(const BVH& bvh, int frameNumber);
-
-
-protected:
-   //! L'ensemble des articulations.
-   //! Remarque : la notion de hiérarchie (arbre) n'est plus nécessaire ici,
-   //! pour tracer les os on utilise l'information "parentID" de la class CAJoint
-   std::vector<SkeletonJoint> m_joint;
-};
-
-```
-
-  
-Dans le Viewer vous devez :
- * Déclarer un Skeleton en variable de la classe
- * écrire une fonction qui fait l'affichage
-
-``` 
-    void CharAnimViewer::skeletonDraw(const Skeleton& ske);
-```
-
- * initaliser l'instance de Skeleton dans la fonction init
- * Appeler setPose dans la fonction update
-
-  
-Remarques :
- * On sépare bien l'affichage de la gestion du squelette pour pouvoir réutiliser le code Skeleton avec une autre librairie d'affichage.
- * On ne s'occupe pas du temps pour l'instant mais uniquement du numéro de la posture.\\
- * Vous pouvez trouvez des BVH dans le répertoire data du code de départ. Notamment le fichier robot.bvh pour debuguer.
-
-  
-  
-## TP partie 2 : Contrôleur d'animation
-
-##### Déplacer une sphère au clavier
-
-Ecrivez une class CharacterControler qui à partir des touches claviers contrôlera le déplacement d'un personnage. Dans une 1er temps faites juste déplacer une boule : accélérer, freiner, tourner à droite, tourner à gauche, sauter. Ce contrôleur comportera une position et une vitesse. La vitesse sera modifiée par les flèches (ou un pad) et la position sera mise à jour dans la fonction update du Viewer en utilisant le paramètre "delta" recu par la fonction update.
-
-Une classe de Controller peut ressembler à ceci.
-
-``` 
-    class CharacterController
-    {
-    public:
-        CharacterController() : ... {}
-
-        void update(const float dt);
-
-        void turnXZ(const float& rot_angle_v);
-        void accelerate(const float& speed_inc);
-        void setVelocityMax(const float vmax);
-
-        const Point position() const;
-        const Vector direction() const;
-        float velocity() const;
-                const Transform& controller2world() const { return m_ch2w; }
-
-    protected:
-                Transform m_ch2w;   // matrice du character vers le monde
-                                    // le personnage se déplace vers X
-                                    // il tourne autour de Y
-                                    // Z est sa direction droite
-                                    
-        float m_v;          // le vecteur vitesse est m_v * m_ch2w * Vector(1,0,0)
-        float m_vMax;       // ne peut pas accélérer plus que m_vMax
-    };
-```
-
-  
-
-##### Déplacer un personnage au clavier
-
-Dans un 2e temps, votre contrôleur comportera également une série
-d'animation bvh : attendre, marcher, courir, et donner un coup de pied.
-En fonction de l'action que veut faire le joueur appuyant sur des
-touches vous changerez d'animation. Vous coderez la machine à états
-finis (FiniteStateMachine) de l'image ci-dessous. Les cercles sont les
-états (l'animation en train d'être jouée), les rectangles rouges sont
-les éventements et les carrés bleus sont les actions à effectuer
-(fonction de la classe). Ce changement se fera brutalement. Ne vous
-occupez pas non plus des pieds qui glissent sur le sol. Un meilleur
-contrôle peut-être fait la construction d'un graphe d'animation.
-
-![](/fsm.png)
-
-  
-  
-
-## TP partie 3 : Transition et plus
-
-a) Pour améliorer le réalisme, il serait bon de faire les transitions
-entre deux animations en choisissant deux poses des animations qui sont
-proches. Pour cela il faut calculer la distance entre deux poses
-d'animations (Voir les infos dans le sujet Graphe d'animation).  
-  
-
-b) Pour aller encore plus loin, on peut construire un automate de
-manière complètement automatique, on appelle alors ceci un graphe
-d'animation. [Voir le sujets de TP
-suivants.](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=master_charanim_tp_m2_cpp&s[]=graphe#tp_3e_partiegraphe_d_animation)  
-  
-
-a.bis) Indépendamment de la machine à état ou du graphe, si vous voulez
-gérer le temps de manière plus juste, il faudrait récupérer le temps
-réellement écoulé depuis l'affichage précédent. Ceci vous fera ne vous
-fera pas tomber précisément sur une frame stocké dans le clip (BVH). Il
-faudra donc interpoler entre les 2 frames. Le résultat sera de l'ordre
-du détail lors de l'affichage mais si vous voulez que votre moteur
-d'animation tourne sur toutes les machines indépendamment du CPU, il
-faut le faire. Cette interpolation peut également servir pour passer
-d'un clip à un autre.
-
-  
-  
-  
-
-## TP partie 3.PLUS : graphe d'animation
-
-*  -* [Motion Graph de l'article original](http://www.cs.wisc.edu/graphics/Gallery/kovar.vol/MoGraphs/);
-* Des BVH avec squelette compatible pour le graphe sont donné dans le git, répertoire Second\_Life.  
-
-Nous avons remarqué dans la partie 1 que la transition d'animation ne fonctionne bien que lorsque les deux poses du squelette sont assez proches (il faut bien sûr également que les deux squelettes aient la même topologie). L'idée d'un graphe d'animation est de construire un graphe où chaque noeud correspond à une pose d'une animation et où chaque arrête définit qu'une transition est possible entre les deux poses.
-
-  
-
-#### Comparaison de deux poses d'animation
-
-Pour construire un graphe d'animation à partir d'une ou plusieurs animations, on doit être capable de comparer deux poses d'animation. Une distance de 0 indique que les deux poses sont identiques. Une distance grande indique que les 2 poses sont très différentes.
-
-A partir de la classe Skeleton, écrivez la fonction de calcul de distance entre deux poses de squelette. Cette fonction est déjà présente dans la classe Skeleton plus haut mais en commentaire. Cette fonction calcule itérativement sur toutes les articulations la somme des distances euclidienne entre chaque articulation de deux squelettes aillant la même topologie mais dans des poses différentes.
-
-```
-    friend float Skeleton::Distance(const Skeleton& a, const Skeleton& b);
-```
-
-  
-Remarque : il est important de ne pas tenir compte de la translation et de la rotation de l'articulation racine. Une même pose a deux endroits du monde doit donner une distance de 0. Dans un 1er temps, votre personnage aura son noeud root centré en (0,0,0), puis dans la dernière partie de cette question, vous traiterez le centre de gravité.
-
-  
-  
-
-#### Construction du graphe
-
-Ecrivez un module MotionGraph qui contiendra un ensemble de BVH et le graphe d'animation définissant des transitions dans cette ensemble d'animation.
- * Un noeud du graphe=(Identifiant d'une animation + un numéro de pose); 
- * un arc du graphe entre deux poses indique la transition possible entre ces deux poses. Deux poses sont compatibles à la transition quand la distance entre les deux squelettes sont inférieurs à un certain seuil fixé empiriquement.
-
-  
-Vous pouvez créer un module CACore/CAMotionGraph.h/.cpp
-
-```
-    class MotionGraph
-    {
-       ...
-    protected:
-       //! L'ensemble des BVH du graphe d'animation
-       std::vector<BVH> m_BVH;
-    
-       //! Un noeud du graphe d'animation est repéré par un entier=un identifiant
-       typedef int GrapheNodeID;
-    
-       //! Une animation BVH est repérée par un identifiant=un entier 
-       typedef int BVH_ID;
-       
-       //! Un noeud du graphe contient l'identifiant de l'animation, le numéro 
-       //! de la frame et les identifiants des noeuds successeurs 
-       //! Remarque : du code plus "joli" aurait créer une classe CAGrapheNode
-       struct GrapheNode
-       {
-         BVH_ID id_bvh;
-         int frame;
-         std::vector<GrapheNodeID> ids_next;     //! Liste des nœuds successeurs 
-       };
-    
-    
-       //! Tous les noeuds du graphe d'animation
-       std::vector<GrapheNode> m_GrapheNode;
-    
-    };
-```
-  
-  
-
-#### Navigation dans le graphe
-
-Une fois ce graphe construit, on peut définir différente manière de naviguer dedans :
-   * Un parcours aléatoire dans le graphe (juste pour vérifier que le graphe est ok);
-   * L'utilisateur donne des directions au clavier => le parcours dans le graphe est conditionné par ces contraintes.
-
-
-#### Gestion correcte du centre de gravité
-
-Pour chaque arc du graphe, vous devez stocker la transformation (soit une matrice 4x4, soit un quaternion et une translation) du noeud root (souvent le centre de gravité) entre la pose i et la pose i+1. Cette transformation sera appliqué au noeud root de votre personnage quand il empruntera l'arc.
-
-  
-  
-  
-
-## NON DEMANDE CETTE ANNEE : Animation physique (voir la partie de F. Zara à la place)
-
-#### Particules
-
-![](/charanim_ball.png)
-
-Dans la fonction init de la class CharAnimViewer indiquez un nombre de particules non nul :
-
-``` 
-    m_world.setParticlesCount( 10 );
-```
-
-Dans la fonction render, il faut afficher les particules en dé-commentant cette ligne :
-
-``` 
-    m_world.draw();
-```
-
-Vous verrez alors les particules s'afficher, mais elles ne seront pas animées. Pour calculer la physique sur les particules, il y a deux
-classes **PhysicalWorld** et **Particle**. Regardez le fichier Particles.h. Il faudra compléter les fonctions update, collision et groundCollision :
-
-``` 
-    void update(const float dt = 0.1f)
-    void groundCollision()
-    void collision(const Point& p, const float radius)
-```
-
-Le code de update doit mettre à jour la vitesse avec l'équation F=m.a où a = dv/dt  
-Et mettre à jour la position avec l'équation habituelle p = p + v.t  
-
-[Regardez les explications dans la vidéo de cours ou ici](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/aPDF_COURS_M1/M1_TP_PhysicsAnimation_ParticulesMassesRessorts.pdf).
-
-  
-
-#### Interaction personnage/particules
-
-Pour ajouter l'interaction entre votre personnage et des boules/sphères se trouvant dans l'environnement, il faut appeler PhysicalWorld::collision depuis CharAnimViewer::update en parcourant toutes les articulations du personnage. Dans un 1er temps, vous pouvez juste faire disparaitre les particules touchées en faisant passer le rayon de la particule à -1 et faire en sorte que les particules de rayon négatif ne soient pas affichées. Puis ajoutez dans Particle::collision du code pour déplacer les particules en collisions (résoudre les collisions) et changer leur vecteur vitesse.
-
-#### Tissus
-
-Un tissu est composé d'un maillage de Masses/Ressorts. Ajoutez une classe Spring qui va comporter :
- * la raideur du ressort
- * la longueur au repos du ressort
- * idA et idB : l'identifiant des 2 particules aux extrémités du ressort. Ces 2 identifiants sont l'indices de deux particules dans le tableau de particules stocké dans la classe PhysicalWorld.
-
-Munissez cette classe d'une fonction *addForce* qui calcule les forces qu'applique le ressort sur les 2 particules.
-```
-    void Spring::addForce(vector<Particles>& part, const float dt)
-```
-
-
-Dans la classe PhysicalWorld, ajoutez un tableau de ressort :
-
-``` 
-   std::vector<Spring> m_springs;
-```
-
-Le constructeur de PhysicalWorld créera un tissu avec des masses ressorts sous la forme de l'image ci-dessous. La génération se fera procéduralement.
-
-![](/mass-spring.jpg)
-
-
-#### Interaction avec le personnage
-
-Normalement, le personnage va pouvoir interagir avec le tissu en passant dessous ...

web/content/personnage/video.md

-
-# CM Animation de personnages virtuels (Master 1ère année)
-
-  * CM = Cours Magistral
-  * Vous pouvez très facilement faire une pause au moment des
-    exercices, revenir en arrière et/ou accélérer la vitesse de la vidéo
-    depuis les options de YouTube (x 1.50 ou plus vite)
-
-
-## CM1 : Animation basée squelette
-Il y a 3 vidéos pour le CM1 :
-     * L'introduction
-     * Un exercice d'affichage de squelette animé très simple
-     * Afficage récursif d'un squelette à partir de la structure de données, présentation du format BVH, prise en main du code du TP
-
-#### CM1.a Introduction
-
-<iframe width="560" height="315" src="//www.youtube.com/embed/TNSesEPrAn0 " frameborder="0" allowfullscreen></iframe>
-
-#### CM1.b Exercice
-
-<iframe width="560" height="315" src="//www.youtube.com/embed/1Js-9r28T-c" frameborder="0" allowfullscreen></iframe>
-
-#### CM1.c Arbre/Squelette, Affichage récursif et BVH
-
-<iframe width="560" height="315" src="//www.youtube.com/embed/1Y8VE9WrSfw" frameborder="0" allowfullscreen></iframe>
-
-
-## CM2 : Edition d\'animations et Contrôle d\'un Personnage Virtuel
-
-<iframe width="560" height="315" src="//www.youtube.com/embed/DfsH9bIIisA" frameborder="0" allowfullscreen></iframe>
-
-## CM3 : Animation et Capture de Mouvements
-
-<iframe width="560" height="315" src="//www.youtube.com/embed/7t98WLxikOo" frameborder="0" allowfullscreen></iframe>