IN - Chapitre 4 - Animation - IUT d'Arles

Imagerie Numérique
Synthèse d’images
4. Animation
DUT Informatique 2012-2013
Sébastien THON
IUT de l’Université de Provence, site d’Arles
Département Informatique

Introduction
Animation = succession d’images fixes, à une fréquence suffisante pour
tromper l’œil (cinéma : 24 images/sec).
(FPS : « Frames Per Second »)
Pour produire une animation : modifier la position d’objets
au cours du temps.
2

En synthèse d’images, 2 types d’animation :
- Animation 3D temps réel
Ex: simulateur, jeu, …
Produit avec une librairie graphique (OpenGL, DirectX, …).
Il faut calculer suffisamment d'images par seconde. Le nombre de FPS
dépend de la machine.
- Animation 3D précalculée
Ex: film d’animation, effets spéciaux, …
Produit avec un logiciel de synthèse d’images (3D Studio Max, Maya,
Lightwave, …).
On peut passer plusieurs minutes ou heures pour calculer une image.
3

3 étapes :
- Modélisation
Représenter les objets par des modèles 3D.
- Animation
Associer un mouvement aux objets.
- Rendu
Créer les images qui composent l’animation.
Modélisation
Animation
Rendu
Dans le cas d’une animation
temps-réel, il faut que cette
boucle soit la plus rapide
possible (effectuée au moins
20 fois par seconde 20
FPS)
4

Animation temps réel
Modélisation
Animation
Rendu
Si lors de l’étape de rendu
on efface l’écran et on
affiche directement les
différents éléments à
l’écran, alors on observe un
effet de scintillement.
5

Solution : affichage en « double buffer »
On utilise deux buffers d’image. On affiche la scène dans un
buffer en mémoire alors que l’autre buffer est affiché.
Lorsque l’image est construite, on permute les deux buffers.
L’image qui apparaît à l’écran est complète
Pas de scintillement
Affichage
échange
Mémoire Écran Mémoire
Écran
6

affichage en « double buffer » avec OpenGL
// Lors de l’initialisation de l’affichage Glut,on requiert un affichage
// en double buffer.
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
// Méthode appelée par Glut pour l’affichage
GLvoid callback_display()
{
// On efface l’image du buffer en mémoire
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// On affiche la scène dans le buffer en mémoire
affiche_scene();
}
// Permutation des deux buffers. Le buffer en mémoire devient visible.
glutSwapBuffers();
7

Remarque:
Si on utilise un affichage en « double buffer », alors on prend
en mémoire vidéo le double de la mémoire nécessaire pour le
« Color buffer ».
Ex: en 1024x768, 24 bits : taille color buffer = 2.25 Mo
en double buffer : 2.25 x 2 = 4.5 Mo
8

Quelques techniques d’animation :
Interpolation de positions-clés
Motion capture
Utilisation d’expressions mathématiques
Cinématique directe et inverse
Simulation dynamique
9

1. Interpolation de positions clés
Permet à l’utilisateur de ne pas avoir à définir toutes les étapes de
l’animation :
• L’utilisateur définit des positions clés (« key frame »)
• L’ordinateur se charge de calculer les positions intermédiaires
par interpolation des positions clés.
10

Interpolation linéaire
Soit un point P(x,y,z) en mouvement. On veut l’amener de (x 0
,y 0
,z 0
) au
temps t 0
au point (x 1
,y 1
,z 1
) au temps t 1
. On peut utiliser une interpolation
linéaire :
Y
X
P(x 1
,y 1
,z 1
)
P(x,y,z)
Z P(x 0
,y 0
,z 0
)
Si on considère que t 0
=0 et t 1
=1, alors :
X(t) = (1-t).x 0
+ t.x 1
avec t ∈ [0 ,1]
= x 0
+ t.(x 1
-x 0
)
Autres interpolations possibles : bicubique, spline, etc.
11

Exemples
Animation de personnages dans les jeux (Quake2, Quake3, etc.)
Animation de visage par interpolation entre des expressions clés.
Au repos Joie Peur Colère
12

2. Capture de mouvement
« Motion capture » (MoCap) : on enregistre les mouvements d'un acteur
pour les appliquer ensuite sur un modèle virtuel.
Cette technique est très utilisée dans les films et dans les jeux vidéos.
Plusieurs techniques existent, utilisant ou non des capteurs sur le
corps de l'acteur, et utilisant ou non des caméras.
13

2.1 Utilisation de capteurs
L'acteur porte des capteurs sur le corps, positionnés sur des points de
références (articulations).
L'acteur est filmé sous plusieurs angles de vue par plusieurs caméras
(très rapides. Vicon MX13 : 484 fps).
Un ordinateur analyse les différentes vues pour retrouver la position en
14
3D de tous les capteurs.

Capture d'expressions faciales
“Facial motion capture”
Utilisation de plusieurs dizaines de capteurs disposés sur le visage.
15

2.2 Analyse sans capteur (« markless »)
Le mouvement est analysé par traitement d'image, en filmant un acteur
avec une ou plusieurs caméras, sans utiliser de capteur.
On peut ainsi capturer des mouvements très subtils (ex: mouvements du
visage) qui nécessiteraient beaucoup trop de capteurs.
(société Image Metrics)
16

Kinect (Microsoft)
La caméra Kinect permet d'obtenir des images optiques, mais aussi une
image de profondeur grâce à un faisceau infrarouge. Des algorithmes
dans le SDK Kinect permettent de repérer la présence de jusqu'à 6
personnes, dont 4 joueurs actifs dont le squelette doté de 20
articulations est calculé en temps réel.
17

2.3 Bilan
Avantages
• Les mouvements obtenus par motion capture sont très réalistes.
• L'animation de personnages est obtenue automatiquement, évitant du
travail à un animateur.
Inconvénients
• Le mouvement est figé, prédéterminé
18

3. Expressions mathématiques
La position des objets 3D en mouvement peut être donnée par une
expression mathématique quelconque dépendante du temps :
x = f 1
(t)
y = f 2
(t)
z = f 3
(t)
Courbes paramétriques (paramétrées par le temps t)
(x L
,y L
,z L
)
Ex: Trajectoire circulaire d’une lune autour
d’une planète :
x L
= x P
+ r . cos(2.π.f.t)
y L
= y P
+ r . sin(2.π.f.t)
z L
= z P
(x P
,y P
,z P
)
r
19

Animation de vagues
Profil d’une vague
Gerstner (1804): le profil d’une vague est une trochoïde.
Chaque particule de l’eau a un mouvement circulaire de
rayon r autour d’un point fixe (x 0
, z 0
)
x = x 0
+ r.sin(k.x 0
-ω.t)
z = z 0
- r.cos(k.x 0
- ω.t)
z
x
20

Modèle : superposition de plusieurs trochoïdes 2D
z
y
n
∑
i = 1
( k ( x.cosθ
+ y.sinθ
) − . t )
h( x,
y,
t)
= A . trochoide
ω
i
Chaque trochoïde est caractérisée par son
amplitude A i
, sa direction θ i
et sa fréquence ω i
.
Ces paramètres peuvent être déterminés à
partir d'un spectre de vague (ex: Pierson-
Moskowitz)
i
x
i
i
i
21

4. Cinématique directe et inverse
Méthodes très utilisées, notamment pour l’animation de personnages
(Half-Life, Unreal Tournament, Max Payne, etc.)
Permet plus de souplesse d’animation qu’une interpolation entre des
positions clés.
On peut obtenir des positions qui n’étaient pas prédéfinies.
(Ex: un personnage qui tombe au sol ne passera pas au travers d’un
mur mais restera adossé).
22

4.1 Squelette et enveloppe
Squelette
Définit la charpente d’un objet.
On anime l’objet en animant le squelette.
En général, le squelette est définit par un ensemble de chaînes.
Enveloppe
Définit l’extérieur visible de l’objet.
L’enveloppe est déformée par le squelette.
23

4.2 Chaînes
Racine (1)
Point de départ de la chaîne.
Os (2)
Ligne droite qui relie deux joints.
Joint (3)
Point de rotation entre deux os.
Point de contrôle (effector) (4)
Placé au bout de la chaîne,
permet d’invoquer la cinématique
inverse.
1
2
4
3
24

Rigging
Rigging = positionnement du squelette par rapport au modèle 3D
du personnage.
Exemple de rigging en vidéo :
http://dbdaishu.com/design/index.php/3d-lab-rigging/114-3d-mayaanimation-rigging-a-model-part-1
25

4.3 Contrôle d’une chaîne
Cinématique directe (« forward kinematics »)
On spécifie directement l’angle de chaque joint de la chaîne.
Cinématique inverse (« inverse kinematics »)
On spécifie la position du bout de la chaîne (« effector ») et on
calcule automatiquement les angles des joints.
26

Exemple de chaîne
Θ 2
l 1
l 2
X=(x,y)
(0,0)
Θ 1
• (0,0) est la racine
• l 1
et l 2
sont les os
• X est le bout de la chaîne (« effector »)
∀Θ 1
et Θ 2
sont les angles des joints
27

Cinématique directe
Θ 2
l 1
l 2
X=(x,y)
(0,0)
Θ 1
• On spécifie directement Θ 1
et Θ 2
• Ensuite on calcule X
28

Cinématique inverse
Que faire si l’animateur connaît la position du bout de la chaîne X ?
Θ 2
l 1
l 2
X=(x,y)
(0,0)
Θ 1
On va calculer les angles des joints Θ 1
et Θ 2
à partir de X
Cinématique inverse.
29

5. Simulation dynamique
5.1 Principe
Certaines animations seraient trop complexes à régler manuellement.
Utilisation d’une simulation dynamique en utilisant des lois de la
physique.
30

5.2 Systèmes de particules
5.2.1 Présentation
Ensemble d’éléments dont les mouvements sont régis par des lois
physiques (gravité, forces de frottement, collisions, etc.)
Ensemble de particules
dotées de vitesses propres
31

Les système de particules permettent de représenter des objets qui
n’ont pas forme bien définie (pluie, neige, feu, fumée, chute d’eau,
explosion, feu d’artifice, etc.)
Les particules peuvent être représentées par de simples points, des
polygones ou des objets 3D. On utilise souvent des quadrilatères
texturés avec une texture RGBA, orientés face à l’utilisateur
(« billboarding »).
32

5.2.2 Attributs des particules
Chaque particule du système est caractérisée par un ensemble
d’attributs, comme par exemple :
• Position
• Vitesse
• Masse
• Taille
• Couleur
• Transparence
• Durée de vie
• etc.
34

5.2.3 Utilisation
Système dynamique : lorsque les particules sont crées, elles ont un
temps de vie au cours duquel leurs attributs peuvent être modifiés, puis
elles disparaissent.
Création Utilisation Suppression
Temps de vie
Modification des attributs
Gestion d’une particule au cours du temps
35

Gestion d’un ensemble de particules
A chaque nouvelle image de l’animation, on effectue les étapes
suivantes :
1. Génération de nouvelles particules
2. Réglage des attributs des nouvelles particules
3. Les particules en fin de vie sont détruites
4. Les particules restantes sont déplacées et transformées en
fonction de leurs attributs
5. Les particules restantes sont affichées
36

Structures de données
class Particule
{
float x, y, z;
float masse;
int duree_de_vie;
};
class Systeme
{
list liste;
};
37

Calcul de la position au cours du temps
Discrétisation du temps, car affiche un certain nombre d’images par
seconde dt = intervalle de temps écoulé entre deux images.
Calcule la distance parcourue pendant un intervalle de temps dt et
l’ajoute à la dernière position connue.
Schéma d’intégration d’Euler :
P(t+dt) = P(t) + V(t).dt
38

Logiciels
Des logiciels permettent de configurer facilement des systèmes de
particules et de les sauver dans des fichiers à des formats (souvent en
XML) qui peuvent être lus par des moteurs de jeu (XNA, Cocos2D, etc.)
ParticleDesigner
http://particledesigner.71squared.com
39

5.3 Simulations dynamiques avancées
Pour représenter de manière très réaliste certains mouvements de la
réalité (solides, liquides, tissus, etc.), on a besoin d’utiliser des modèles
physiques = des équations qui décrivent ces mouvements au cours du
temps en fonction des forces en jeu, selon les lois de la mécanique (des
solides, des fluides, etc.)
Problème : les temps de calculs sont souvent très élevés.
Solution : faire le moins de calculs possible, approximation des
équations on peut obtenir du temps réel. De telles animation
physiques apparaissent dans les jeux vidéos.
40

5.3.1 Utilisation de la mécanique des solides
Utilisation des lois du mouvement énoncées par Newton :
• principe d’inertie :
S'il n'y a pas de force qui s'exerce sur un corps ou si la somme des forces s'exerçant
sur lui est égale au vecteur nul, la direction et la norme de sa vitesse ne changent
pas (=accélération nulle).
• principe fondamental de la dynamique :
L'accélération subie par un corps dans un référentiel galiléen est proportionnelle à
la résultante des forces qu'il subit, et inversement proportionnelle à sa masse m.
• principe des actions réciproques :
Tout corps A exerçant une force sur un corps B subit une force d'intensité égale, de
même direction mais de sens opposé, exercée par le corps B.
Prise en compte des objets, des relations de jointure entre ces objets,
des forces appliquées aux objets (gravité, collisions, frictions).
Animation très réaliste de véhicules, de collision d’objets (billard,
bowling), d’objets articulés (personnage, grue, robot), de cordes, de
cheveux, etc.
41

Animation d’objets rigides
42

Animation de tissus
Principe: maillage 2D de sommets reliés par
des liaisons plus ou moins élastiques (système
masses-ressorts). Des forces sont appliquées
sur les sommets (gravité, etc.)
43

Animation de cheveux
De nombreux modèles ont été proposés par
des chercheurs, cherchant un compromis entre
temps de calcul et réalisme.
Cheveu modélisé par un
système masses-ressorts
Laboratoire GRAVIR, Grenoble
44

Utilisation de la mécanique des fluides
Utilisation des équations de Navier et Stokes, qui décrivent le
comportement de fluides (liquides, gaz) en fonction de leur viscosité, de
la pression, de la température, du temps, des forces en présence.
L’espace qui sera rempli par l’eau est discrétisé en un maillage 3D de
sommets. Au cours du temps, des vecteurs vitesse de fluide sont
calculés en chaque sommet du maillage grâce aux équations de Navier-
Stokes. Des particules de fluide sont placées dans cette matrice 3D.
Leur position est donnée par interpolation des vecteurs vitesse.
Maillage 3D de sommets
45

Animation de liquides
http://physbam.stanford.edu/~fedkiw/
46

Animation de gaz
http://physbam.stanford.edu/~fedkiw/
47

5.4 API physiques
HAVOK
http://www.havok.com
Utilisé dans plus de 200 jeux sur PC, PS2, PS3,
PSP, Wii, XBOX, XBOX 360.
(Assassin's Creed, Bioshock, Company of Heroes, Fable 2,
Fallout 3, FEAR, Halo 3, Spore…)
NVIDIA PhysX
http://www.nvidia.com/object/physx_new.html
TOKAMAK (Gratuit)
http://www.tokamakphysics.com/
ODE (Open Dynamics Engine) (Gratuit)
http://www.ode.org
BULLET (Gratuit)
http://bulletphysics.org
…
48

Box2D
Moteur physique open source (C++,
Flash, iPhone/iPad, ...) permettant de
simuler la mécanique des solides
rigides en 2D.
http://box2d.org
PhysicsEditor
Angry Birds
49

6. Collisions
Le test de collisions entre des objets dans une scène 3D est
indispensable dans une application 3D interactive (simulateur, jeu, …) :
- Est-ce que l’avion a touché le relief du sol ?
- Est-ce que le personnage est contre le mur du couloir?
- Est-ce que le boulet de canon a touché le bateau ?
- …
50

6.1 Principe
Dans le cadre d’animation d’objets, on est confronté au problème des
collisions entre ces objets.
Détection de collision
Déterminer quand et où deux objets se touchent.
Résolution de collision
Déterminer comment la collision affecte le mouvement des objets.
51

6.2 Détection de collision
Pour détecter si deux objets sont entrés en collision, il faudrait vérifier si
le volume de l’un intersecte celui de l’autre, en testant chacun de leurs
triangles.
Très lourd en temps de calcul.
60000 triangles
5000 triangles
52

Accélération de la détection de collision
Il est nécessaire de mettre en œuvre des stratégies d’accélération de la
détection de collision :
- Partition de l’espace
- Volumes englobant les objets
On utilise souvent les deux simultanément.
53

6.2.1 Partition de l’espace
On divise l’espace de la scène 3D en régions.
On peut accélérer la recherche de collisions entre 2 objets :
si les 2 objets appartiennent à des régions différentes, alors ils ne sont
pas en collision.
54

1) Partition uniforme de l’espace
On divise l’espace de la scène 3D en régions de mêmes tailles.
Problème : certaines régions peuvent contenir des milliers de
polygones, et d’autres très peu voire aucun.
55

2) Partition adaptative en quadtree ou octree
On divise l’espace de la scène 3D en régions de telles manière à ce
qu’elles ne contiennent pas plus de polygones qu’un nombre donné.
56

6.2.2 Volumes englobants
Pour accélérer le test de collision entre 2 objets : test d’intersection entre
leur volumes englobants (sphère, boîte, objet simplifié, etc.)
Beaucoup plus rapide.
Test de collision de deux objets 3D, en testant l’intersection
entre leurs boîtes englobantes
57

1) Sphère englobante
Test de collision très simple :
R 1
R 2 d > R 1
+ R 2
Pas de collision
d
R 1
R 2
d
d < R 1
+ R 2
Collision
Deux sphères entrent en collision si la distance qui sépare leurs
centres est inférieure à la somme de leurs rayons.
58

2) Boîte alignée par rapport aux axes
(AABB : Axis Aligned Bounding Box)
z
x
Des collisions peuvent être détectées à tort.
59

3) Boîte à l’orientation quelconque
(OBB : Oriented Bounding Box)
z
x
Plus précis que AABB, mais plus coûteux à calculer.
60

Algorithmes d’intersections entre différents types de volumes:
http://www.realtimerendering.com/int/
Test de collision entre volumes englobants :
- Très rapide
- Mais approximatif
Améliorations :
Liste de volumes englobants
Hiérarchie de volumes englobants
61

Dans le moteur physique Reactor utilisé par 3D Studio Max, on peut
détecter plus ou moins finement les collisions en utilisant une boîte
englobante, ou un sphère englobante, ou une enveloppe convexe, ou
une enveloppe concave, etc.
Enveloppe englobante
de + en + précise
( temps de calculs
plus élevés)
62

Problème
Animation : échantillonnage du temps (x images/sec)
Si les objets se déplacent rapidement, ou si le nombre d’images par
seconde est insuffisant, on risque de manquer une collision.
t 0
t 1
Est ce que la boîte est entrée en collision avec la sphère entre le
temps t 0
et le temps t 1
?
63

7. ODE (Open Dynamics Engine)
http://www.ode.org
Bibliothèque open source de fonctions.
Simulation physique basée sur la mécanique des solides ( objets
rigides, donc pas de tissus, de fluides, etc.)
ODE comporte deux composantes principales :
• Un moteur de simulation dynamique
• Un moteur de détection de collision
64

7.1 Body et Geom
Chaque élément de la scène pouvant être animé physiquement doit être
doté :
• D’un body : propriétés dynamiques (vitesse, masse, etc.)
• D’un geom : propriétés géométriques (enveloppe géométrique
servant à la détection de collision, position, orientation) mais ne
servant pas à l’affichage.
Classes de géométrie possibles pour l’enveloppe géométrique :
• Sphere
• Box
• Plane
• Cylinder
• Ray
• Triangle mesh
65

7.2 Jointures
Différents types de jointures peuvent être défini entre les body de deux
objets afin de d’imposer des contraintes :
Ball and socket Hinge Universal
Slider
Hinge2
66

7.3 Structure typique d’un programme
• Créer un monde dynamique
• Créer des bodies dans le monde dynamique
• Définir l’état de tous les bodies (position, etc.)
• Créer des jointures dans le monde dynamique
• Attacher les jointures aux bodies
• Définir les paramètres des jointures
• Créer un groupe de jointures temporaires pour les points de collision
• Boucle :
• Appliquer des forces sur les bodies si nécessaire
• Ajuster les paramètres des jointures si nécessaire
• Appeler la détection de collision
• Créer une jointure de contact pour chaque point de collision et
l’ajouter au groupe de jointures temporaires
• Faire un pas de simulation
• Supprimer toutes les jointures du groupe temporaire
• Supprimer le monde dynamique
67