---
title: Synthèse d'image
date: 10-02-2020
tags: Image, ISIM
---

# [ISIM] Synthèse d'image

les slides du cours : http://jo.fabrizio.free.fr/teaching/synt/index.php

## Intro

Durant les deux ans il va falloir apprendre plein de choses sur la synthèse
* rendu
* interaction

Changer de regards sur films/jeux vidéo : se demander quelles méthodes utilisées, si c'est correcte ou non

Informatique graphique :
* modélisation de la forme
* modélisation des mouvements/interaction : respecter lois de la physique (sinon ça casse le réalisme)

Deux grandes familles :
* rendu temps réel (ex. jeux vidéo/simulation) ; doit être beau et réaliste mais 'tous les coups sont permis'
* rendu photoréaliste (ex. films) ; pas besoin de temps réel, peut prendre une journée

### Modélisation

Objectif : modéliser les objets. Certains sont plus ou moins durs à représenter :
* object classiques
* objets en mouvements / déformations
* feu, nuage, ect

Pour modéliser les objets :
* artistes créant les modèles
* ex de némo : sculpture scannées ; encore beaucoup utilisé, mais sûrement voué à disparaître ? (nouvelles générations habituée à travailler avec ces outils)

Pour modéliser les mouvements :
* regarder les mouvements d'un objet et essayer de le reproduire
* rajouter de la physique aux objets (modéliser une chute libre par exemple)
* capture du mouvement (comme Avatar(Les bonhommes bleus) ou Golluuum)

Les techniques de modelisation sont ecrites sur les slides.

### Domaines liés

* Programmation GPU (qui peut permettre d'autres calculs que le rendu d'image); beaucoup d'engouement mais correspond à des processeurs hautements parallélisés
* Traitement d'images (HDR : high-dynamic-range imaging)

Bien connaitre son materiels, car on le sous exploite trop souvent.

### Historique

Envie/nécessité de faire des images de synthèse est apparue avec l'écran.

L'ecran CRT : En gros, c'est des particules qui tapent l'ecran, et ça reagit avec un produit chimique, et des couleurs sont generées.

A partir des années 70 : apparation des méthodes de rendue comme z-buffer ect. Assez étonnant de les voire déjà car extrêmement gourmand en calcul.

### Communauté scientifique

Conférence du SIGGRAPH présente les algos les plus importants.

### Outils

:::warning
Il faut prendre en main Blender
:::

Dans la pratique, il faut prendre en main certains outils :
**Rendu réaliste**:
* Blender ; moteur de modélisation et rendu (conseillé); plusieurs systèmes de rendus
* POVRAY est un système de rendu (assez ancien)
* Maya (pro)

**Rendu temps réel**, il existe des API bas niveau :
* Direct3D (monde microsoft)
* OpenGL (portable); mais NVIDIA ne veut pas investir dans son dévelopement
* Vulkan (très bas niveau)

Pour faire un jeu, les API graphiques sont trop bas niveau. Un moteur semble plus adapté.
**Moteur**:
* Unity
* Ogre
* Unreal engine? (c'est cher)

### Quizz : films

:::warning
Askip nos devoirs c'est de regarder des films qui (aujourd'hui) donnent envie de se suicider.
(ce qui est plutôt cool!)

A regarder en entier :
* Tron
* The last star fighter
* Terminator 2
:::

**Tron** (1982) est un des premiers films en image de synthèse. Fabrizio conseil de regarder un historique dessus.

**The last star fighter** (1984); beaucoup de séquence par ordinateur mais se voit pas trop ?

**Terminator 2** (1991) à regarder 2 fois (une pour l'histoire et une pour les passages de synthèse d'image)

**Jurassic Park** (1993); "les bêbêtes sont vraiment très très bien faites"

**Explorer** (1985): il faut regarder l'historique de comment ils ont fait ça

**Young Sherlock Holmes** (1985): faut absolument regarder la sequence avec l'homme qui sort du vitrail

**Le cobaye** (1992)

**Toy story** (1996): premier long métrage entièrement de synthèse

**Fourmiz** et **Mille et une pattes** (1998): dans le deuxième, l'animation des branches est impressionantes

**Monstre et compagnie** (2001) très marquant par la fourrure de Sully (le monstre bleu poilu)

**L'age de glace** (2001): déçu, le fond est blanc, moins travaillé

**Némo** (2003): mouvements des poissons impressionants, fait à la main à partir de vrai poissons

**Final fantasy : les créatures de l'esprit** (2001): regarder les 15 premières minutes, après c'est nul

### Quizz : jeux vidéo

**Star wars** (83-87-88-89) un des premiers jeux 3D

**Driller** (1987)

**Relief Action** (1987): "vraie" image en 3D (deux rendus différents)

**Alone in the dark** (1992)

**Resident Evil 1 et 2** (1996 - 1999)

**Wolfenstein** (2001): fausse 3D avec beaucoup d'astuces, très malin

**Doom** (1993)

**Dark forces** (1995): se démarque mais pas très connu

**Myst** (1993): à l'état de l'art de ce qui se faisait à l'époque ; très beau pour l'époque (que du précalculé)

**Descent**: du vrai 3D avec des textures plaqués

**Terminal velocity**: objets en 3D (vaisseaux, radars)

**Flight Gear Simulator**

### Module ISIM

OpenGL : on appliquera les algo de rendu en temps réel

Evaluation : à priori, pas d'examen sur table (bien qu'il semble hésiter).

Le Projet :
* en binome (no arnac no noob)
* rapport + soutenance (pas raconter sa vie ; 2-3 pages, concit et droit au but (pas comme le rapport de stage(ptdr))) (max 10 minutes questions comprises)
* Video courte 1/2min (synthetisé)

Les soutenances se feront probablement en classe entière (surtout en OpenGL pour découvrir les autres techniques).

Au niveau des sujets, il y en aura plusieurs (différents algos de rendu). Si quelque chose nous motive, on peut proposer quelque chose, on discutera de si c'est trop facile/difficile.

## Rappels (ou pas)

http://jo.fabrizio.free.fr ou http://www.lrde.epita.fr/~jonathan
pour les supports de cours, sujets de TP, etc

### Optique

pour former une image, il faut une source lumineuse, qui va frapper les objets et rebondir dessus (refléction/réfraction) jusqu'à arriver à notre oeil.

### Couleur primaires

**Synthèse additive**: quand c'est émit par une source ; si j'envoi plusieurs couleurs je peux les combiner pour en faire une autre (lié à notre perception), on rajoute des longueurs d'ondes
- rouge
- vert
- bleu

**Synthèse soustractive**: quand un objet absorbe la lumière d'une source lumineuse ; d'un point de vue physique c'est une source lumineuse mais ne produit pas sa propre lumière (source secondaire):
* magenta
* cyan
* jaune

Les couleurs primaires sont directement liées à nos perceptions visuelles.

### Capture de l'image

Besoin de capteur numérique pour notre utilisation.

:::warning
Besoin de comprendre comment ça marche, car nous auront besoin de le modéliser pour afficher des images (souvenirs souvenirs de raytracer)
:::

Sur un objectif, beaucoup de paramètres à régler :
* ouverture de champs ; correspond à la distance focale (jolie nom pour zoomé/pas zoomé) (distance focale plus courte = panorama, plus grande = zoomé)
* si le foyer n'est pas ponctuel (diaphragme ouvert), problème de profondeur de champs (correspond au flou dans le fond/premier plan)
* si le diaphragme est ouvert, plus du luminosité


Modèle sténopé, utilisé en informatique. Différent de l'oeil car affiche "dans le bon sens" par rapport à un appareil photo/oeil.

La profondeur de champs n'est pas modélisé sur le modèle sténopé.

Différents type de capteurs : CCD et CMOS

#### Capteur CCD

matrices de capteurs photosensibles
charges électriques en fonction de l'intensité de la lumière (niveau de gris)

on est capable de récupérer la quantité de lumière mais pas la longueur d'onde (donc noir et blanc)

#### Capteur CMOS

mais si on connait quantité de rouge, quantité de bleu et quantité de vert on est capable de reconstituer la couleur

par groupe de 4 pixels, filtres de chaque couleur primaire
on double le capteur vert, car notre oeil est plus sensible à cette couleur (plus d'information)


#### Capteur tri-CCD

démultiplie l'image et envoie sur un CCD bleu/rouge/vert. C'est super top en théorie, mais le prof ne sait pas comment ça garantie que les images coincident

### Spectre

Spectre : visible = 400nm à 800nm (bleu -> rouge)


### Perception humaine

On a des capteurs qui se soucient de l'intensité lumineuse (bâtonnets)

et des capteurs s'occupant de la couleur (cônes), divisé en trois familles (abusivement, rouge vert et bleu)

### Codage de la couleur

**Modèle RGB**: amplitude des 3 capteurs (un cube)
(Pour jouer avec du RGB : https://www.w3schools.com/colors/colors_picker.asp)


### Géométrie (wiz)

On va parler de géométrie projective (en opposition à géométrie euclidienne, qu'on connait déjà)

**Produit scalaire** permet entre autre de déduire l'angle entre deux vecteurs

Espace affine
Espace vectoriel + norme

**Produit Mixte**
**Produit vectorielle**: utile pour calculer les normales aux surfaces (puisque ça calcule la normale à deux vecteurs)

:::warning
Il n'y a pas d'équation cartésienne de droite dans l'espace
Une droite dans l'espace = intersection de 2 plans (donc nul), faut trouver une autre représentation => Un point et un vecteur
:::

:::danger
Revoir équation d'un plan, ect. A remplir ici ? (le prof passe dessus)
* équation plan/sphère
* intersection droite/plan droite/sphère
:::

Algorithme de Cyrus-Beck

#### Géométrie projective

Pas l'habitude, mais nos yeux marchent de cette façon. Pas comme les objets sont mais comment ils sont vus (voir exemple du prof)

Projection de l'objet sur un plan image (intersection entre le plan image, et la droite objet-foyer)

En géométrie projective, les droites parallèles vont converger vers un point de fuite. De même, les angles droits d'un dammier (par exemple) ne sembleront plus droits.

Horizon = plan parallèle au plan objet et qui passe par le foyer

On rajoute des points à l'infini ~(pour les homologues) en plus de la géométrie euclidienne.

Chaque ensemble de droites parallèles convergent vers le même point à l'infini.

Changer de plan pour pouvoir représenter les points à l'infini. On augmente la dimension (si l'espace euclidien correspondant est en 2D on prend 3 dimensions, par exemple).
Plusieurs coordonnées vont définir le même point à l'infini : il existe k tel que p1 = kq1, p2 = kq2 et p3 = kq3 => p et q sont le même point à l'infini

De ce fait, si $p3\neq0$ on peut enlever la dimension supplémentaire (en divisant les autres coordonnées par p3).

### Transformations usuelles

**Translation**: un vecteur + vecteur de position
**Rotation**: il faut un angle et une origine ; matrice * vecteur de position

Matrice de rotation 2D autour de l'origine :
$$\begin{pmatrix}
\cos \theta & \sin \theta \\
-\sin \theta & \cos \theta
\end{pmatrix} $$

Une translation/rotation en géométrie projective :
$$R \times T \times P$$

$$R=\begin{pmatrix}
\cos \theta & \sin \theta & 0 \\
-\sin \theta & \cos \theta & 0 \\
0 & 0 & 0
\end{pmatrix}$$

$$T=\begin{pmatrix}
1 & 0 & t_x\\
0 & 1 & t_y\\
0 & 0 & 1
\end{pmatrix}
$$

$$P=\begin{pmatrix}
x\\
y\\
1
\end{pmatrix}
$$

Utile si plusieurs rotation/translations car on peut avoir une seule matrice au final.

## Rendu photoréaliste

Différentes stratégies :
* Monte Carlo rendering algorithmes
* Deterministic rendering algorithmes
* Image based rendering algorithmes
* Object based rendering algorithms

Deux stratégies globales :
* calculer l'illumination partout puis regarder d'un certains point de vue (Object Based)
* calculer uniquement en fonction des lumières qui arrivent à ma caméra (image based)

Le premier est évidemment plus long mais on n'oublie rien, contrairement au deuxième.

**Méthodes classiques**:
* raytracing: ce qu'on va coder
* pathtracing et bidirectionnal pathtracing ; image très très photoréaliste
* Point based Global Illumination - PBGI ; très peu connu en dehors de l'industrie cinématographique, mais cool
* Radiosity (illumination globale)
* Photon map ; difficile à mettre en oeuvre mais "résultats intéressants"

### Partir de la source lumineuse

Le problème est quand on part de la source lumineuse, on ne sait pas lesquels vont finir par arriver à l'oeil (à cause de la réflection/réfraction).

Une solution est de lancer plein de rayons depuis la source en espérant que ça passe. Il faudrait en lancer une infinité dans l'idéal.

### Partir de l'oeil (Raytracing)

On sait que l'on peut faire le chemin inverse du rayon : on lance depuis l'oeil jusqu'à la source lumineuse. C'est l'idée de base du raytracing.

**Raycasting**: déterminer les objets vu par l'oeil (pas de rebonds, tout ça)


La difficulté, en terme de temps, est que l'on doit faire l'intersection entre le rayon et **TOUS** les objets de la scène (bien qu'il y ai des astuces pour en faire moins).
Garder l'objet le plus proche si on trouve des intersections
Puis on calcule les contributions des sources lumineuses primaires de la scène (mais tout est une source lumineuse, même secondaire, les reflets), on va juste explorer le rayon réfléchi par l'objet.

**partie spéculaire**: si la lumière est dans le rayon de réflection = pas de filtre

Calcul de l'illumination globale :
* composante diffuse
* composante spéculaire
* apport des sources primaires
* apport des sources secondaires (à ce stade, on ne sait pas trop cmt faire)

**Lumière directionnelle**: soleil, laser

Modèle local :
pour simplifier on prend le plan tangent à la surface observé

**Apport du diffus**: dépend de l'angle entre la normale et la source :
$$ I_d = k_d \times C \times (N.L) \times I_{Li}$$

Où:
* $N$ est la normale (normalisée)
* $L$ est la direction des rayons source (normalisée)
* $C$ est la couleur de la surface de diffusion
* $k_d$ est la composante de diffusion de la surface en question
* $I_{Li}$: intensité de la source lumineuse

**Spéculaire**:
$$I_s = k_s \times I_{Li} \times (S.L)^n$$

Où:
* $k_s$ est la composante spéculaire de la surface
* $S$: direction du rayon réfléchi
* $L$ est la direction des rayons source (normalisée)
* $I_{Li}$: intensité de la source lumineuse
* $n$: est le coefficient de Phong (certain l'appelle la brillance)

Ah, c'est chouette !

http://jo.fabrizio.free.fr/teaching/synt/isim_rendu_photorealiste.pdf
algo page 29

**Source secondaires**
direction privilégié = rayon réfléchi
On relance simplement un rayon dans cette direction, qui va faire exactement les mêmes calculs (spéculaire, tout ça tout ça). Il y a plusieurs solutions pour arrêter cet algorithme récursif :
* arrêter au bout de x itération
* quand y'a plus d'intensité de lumière

**Ombres**: on relance un rayon vers la source lumineuse : si on rencontre un objet, c'est que la source lumineuse primaire n'influe pas.

Ouais !

#### Avantages vs Inconvénients

Avantages :

* Algo simple et rapide à implémenter
* Génère des images honorables

Inconvénients :

* Ombres très différentes de la réalité
* Pas d'objets transparents
* Beaucoup d'aliasing

#### Aliasing: solution avec cast ray

Solution : lancer plusieurs rayons par pixels. *(De toute façon, la solution est toujours castray)*

Stratégies :
* redécouper le pixel en plusieurs parts : pas excessivement bonne dans la pratique
* lancer des rayons aléatoires dans cette surface : étonnement meilleur

Pourquoi l'aléatoire donne de meilleures résultats ? Il y a un risque qu'un objet éloigné passe entre deux rayons. Mais en projetant des rayons aleatoirement, on augmente les chances de toucher l'objet, cependant, cela ne marche pas très bien dans des animations.

Amélioration (performance): pas besoin de sur-échantilloner si le gradient est faible.
Uniquement sur les gradients forts, déterminé par un premier rendu

**Autres techniques**
* Appliquer un flou gaussien, très rapide mais pas idéal en terme de rendu, il y a des zones que l'on ne veut pas nécessairement flouter

#### Temps de calcul

Problème : c'est long

Solutions :
* Parallélisation (*OpenMP*)
* Partitionnement de l'espace (*via des structures comme grilles homogènes :-1:, [octree](https://en.wikipedia.org/wiki/Octree), [kd-tree](https://en.wikipedia.org/wiki/K-d_tree), [**BSP** (à connaître)](https://en.wikipedia.org/wiki/Binary_space_partitioning)*)
* Volume englobant : on entoure une structure de polygones complexe par une plus simple. Si le rayon ne touche pas le volume, on passe au prochain objet (*[BVH](https://en.wikipedia.org/wiki/Bounding_volume_hierarchy)*)

On ne peut pas utiliser de cache pour les sources secondaires :
* l'espace est continu
* on ne peut pas supposer que deux points côtes à côtes sont éclairés de la même façon

#### Transparence

Implémenter la réfraction

**Problème:** l'indice de réfraction diffère en fonction de la longueur d'onde

On simplifie en prenant le même indice pour toutes les couleurs, ce qui est une approximation correcte dans la plupart des cas usuels.

**Combiner réflexion et réfraction**: équation de Fresnel.

:::info
Il existe une **simplification** des équations de Fresnel en *Computer Graphics* (maintenant il faut la trouver)
:::

**Il y a une difficulté en terme de réfraction.**

**Difficulté**: si il y a un objet transparent lorsque l'on vérifie si un point est à l'ombre ou non, c'est particulièrement complexe. On peut approximer ça en appliquant le filtre sur la couleur mais en ne déviant pas le rayon lumineux (ce qui est parfaitement faux d'un point de vue physique, mais pas mauvais visuellement).

**Milieux translucides**

Surfaces qui laissent passer la lumière, mais qui dévient la lumière de telle sorte que l'on arrive pas à distinguer les formes des objets ;
En gros : vitres de salles de bains ou toilettes.

$\rightarrow$ Distribution probabiliste pour calculer les rayons réfractés

#### Caustique

**Définition** convergence des rayons lumineux vers une surface

#### Éclairage indirect

Solution : éclairage ambiant (ou castray, comme d'hab (mais ça c'est du pathtracing donc on verra plus tard)). C'est une solution approximative mais hyper rapide à calculer.

#### Le retour de l'ombre

Le problème est qu'on gère les sources lumineuses comme ponctuelles : l'ombre est donc binaire. Or la source lumineuse a un volume, il faut pouvoir différencier les cas où l'on la voit, où on ne la voit pas et où on la voit partiellement.

**Solution 1** au lieu d'avoir une seule source, on en crée plusieurs petites sources.

**Solution principale** *castray* (vers le volume de la source)

### Bilan raytracing

**Avantages**
* très simple
* donne des images honorables

**Problèmes**
* c'est lent
* les sources secondaires sont mal gérées
* objets transparents mals gérés

#### Améliorations du raytracing

* Raytracing distribué (84)

:::warning
**Remarque**
Pour vérifier si un point donné est à l'ombre ou non, on relance un rayon en direction de la source concernée en vérifiant si un autre objet est sur la trajectoire.

**Problème**
Il arrive que la position du point testé soit calculée en dessous de sa surface (arrondis de flottants), et que le rayon renvoyé vers la source entre en collision avec la dite surface. Cela donne un point d'ombre faux.

**Solution**
Lors d'une intersection, avant de relancer un rayon:
* on peut décaler par rapport à la normale (pas ouf car on décale tous les points de l'espace)
* Sinon on se décale par rapport au vecteur d'énergie.
* c'est quoi vecteur d'énergie -> le rayon incident
:::

## Radiosité

Quantité d'énergie que chaque objet émet/renvoie

Permet de mieux de gérer les sources secondaires mais assez lourd, nécessite un maillage et doit être recalculé à chaque changement de scène

Peut être utilisé combiné avec le raytracing pour améliorer sa lumière diffuse.

En terme de performance, plutôt bien car on peut rendre rapidement depuis autant de point de vue que l'on veut une fois calculé, **MAIS** il faut tout recalculer si un seul objet de la scène bouge (dans le cadre d'une animation).

## Photon Map

Début des années 2000

**Objectif** résoudre le problème de l'illumination mais (contrairement à la radiosité) en prennant en compte les objets transparents.

Précalcul de l'illumination de la scène.

On lance des pitits photons depuis les sources. Lorsqu'un photon intersecte un objet, il dépose un peu d'énergie.

On regarde ensuite l'accumulation d'énergie déposée par tous les photons sur la scène.

**Permet de gérer les caustiques :D (j'aime)**

> *"A coder, c'est un cauchemar"*

Potentielles améliorations du photon mapping :
* Cf slides

## [Path Tracing](https://en.wikipedia.org/wiki/Path_tracing)

**On abandonne le raytracing**: on a envie de gérer correctement les caustiques, sources lumineuses secondaires, transparences, ...

**[BRDF](https://en.wikipedia.org/wiki/Bidirectional_reflectance_distribution_function) (Bidirectional Reflectance Distribution Function)**: pour chaque rayon qui heurte une surface, quel est le ratio de luminance énergétique qui est réfléchi

### Principe du rendu

Avec le ray tracing, on relance un seul rayon vers les sources lumineuses. Ici, on tire de multiples rayons, un peu partout, en choisissant intelligemment les directions (*"c'est du bruteforce intelligent"*). Pour ne pas fausser le rendu on n'utilise pas une distribution équilibrée, mais une distribution probabiliste, en tirant plus de rayons là où la lumière est le plus réfléchie.

### Avantages/inconvénients

- Avantages:
* très réaliste
* convient aux scènes extérieures
* rend les caustiques
* possibilités de modéliser certains effets comme la profondeur de champs

On peut simuler la profondeur de champs, car on lance plein de rayons: on lance les rayons sur tout le foyer au lieu de considérer que le foyer est ponctuel.

- Inconvénients:
* bruteforce: prend beaucoup de temps de calcul // lent
* bruitage: pendant le processus, le **rendu sera très bruité**, il y aura beaucoup de variations entre les pixels.
* difficile pour les scènes avec des petites sources lumineuses

:::warning
Lancer un rayon lumineux en esperant qu'il remontera jusqu'a la source lumineuse, c'est avoir beaucoup d'espoir (*et de patience*).
:::

## [Bidirectional Path Tracing](https://en.wikipedia.org/wiki/Path_tracing#Bidirectional_path_tracing)

Au lieu de lancer des rayons uniquement depuis l'oeil, on lance aussi des rayons depuis les sources lumineuses.
Puis on cherche les interactions entre les deux rayons tirés.

A priori, on perd un petit peu en photoréalisme, mais converge bien plus rapidement.

## PBGI: Point-Based Global Illumination

Algorithme beaucoup utilisé dans le monde du cinéma, mais assez peu connu.

Algorithme assez rapide, image non bruitée
On va considérer des disques sur la surface des objets (à la place des points)
On regroupe les points (disques) s'ils sont éloignés

On calcule l'apport des sources secondaires en fonction de leur distance:
* si les disques sont loin, on considère l'apport comme une seule entité (cluster)
* s'ils sont plus proches, on considère chaque disque individuellement

# Modélisation

## Types de rendus

- rendu temps réel
- maillages/polygônes
- rendu photoréaliste (raytracing...)
- maillage/polygones
- mathématiques (équation des surfaces)
- animation
- Modèles physiques

On peut décrire chaque surface d'objets par leur formule mathématique, mais ça devient vite compliqué pour autre chose que des formes simples (sphères, cubes, plans...).

## Maillages

Si on n'utilise pas l'équation, on va le modéliser comme un maillage.

Construction d'objets par assemblage de polygones (meshes)
- Bonne modélisation, peu de courbes
- Peu compact mais facile à manipuler

### Représentation

On utilise principalement le triangle, qui facilite le traitement.

Implémentation :
- Liste de sommets de polygones, mais
- Duplication des sommets, car chacun appartient à plusieurs triangles
- Topologie inconnue (?)

Pour passer d'un polygone quelconque à des triangles, on peut utiliser la triangulation de Delaunay.

**Adaptive mesh refinement** Pour améliorer les performances du rendu temps réel, on peut réduire/améliorer les détails des meshs en fonction de leur distance à la caméra.

**Courbes de Béziers (1960 - *Renault*)** permet de modéliser de "belles" courbes entre deux points, grâce à l'ajout de ($2^{d-1}$, $d$ = dimension) points de contrôles (permettant de contrôller la forme de la courbe). Peut être étendu facilement pour faire des **surfaces** ou des **volumes**.

### Algorithmes de lissages

**Algorithme de [Catmull-Clark](https://en.wikipedia.org/wiki/Catmull%E2%80%93Clark_subdivision_surface)** (attention, erreur de nom dans les slides) permet d'arrondir les angles lorsque l'on fait plusieurs itérations. Peut être très utile en modélisation: on fait un objet grossier et on fait plusieurs itérations de l'algo.

### Modélisation par assemblage ([C.S.G](https://en.wikipedia.org/wiki/Constructive_solid_geometry))

On modélise en combinant des briques de bases via:
* union (moins utile)
* intersection
* différence

### Modélisation par révolution

C'est vachement stylé. Mais c'est pas un Graal. Et c'est putain de lourd en calcul. Mais c'est stylé.

On fait tourner une courbe en 2D autour d'un axe, l'objet 3D sera l'ensemble des points par lesquels la courbe est passée.

### Modélisation par extrusion

On ajoute un troisième axe à une surface 2D (ex: donner une hauteur).

### Blobs/Metaballs

**Isosurface** On a un contour mal définit, on ne peut donc pas définir l'équalition de la surface. On représente donc l'isosurface une surface dont l'énergie va décroître en fonction de la distance.

En utilisant plusieurs isosurfaces proches, on peut générer des formes intéressantes (ex: une goutte avec une grande isosurface et une petite isosurface).

### [Modélisation des plantes (L-System)](https://fr.wikipedia.org/wiki/L-Syst%C3%A8me)

Souvent utilisé pour modéliser la végétation (mais a d'autres applications).

On a une règle de génération qu'on applique récursivement. L'algorithme est très simple à mettre en oeuvre. La difficulté est de mettre en place les bonnes règles de générations pour obtenir ce que l'on souhaite (ex: un arbre n'aura pas les mêmes couleurs partout en fonction de la hauteur).

### Acquisition

On sculpte un objet puis on le scan pour obtenir un modèle 3D.

Si on ne sait pas sculpter dans la réalité, il existe des techniques pour "tailler" ou "ajouter" des formes dans un maillage (en gros, sim city).

### Scène

Catalogue d'objet. La scène est simplement un ensemble d'objet (potentiellement avec translation/rotation/homothétie).

Pour les objets articulés, on peut utiliser une représentation hiérarchique.

## Textures

Permet:
* simplifier la modélisation de la scène (ex: plutôt que de modéliser chaque bâtiment, on modélise des cubes et applique des textures dessus)
* avec les matériaux, ajouter du réalisme

Types:
* textures procédurales
* textures plaquées (à partir de formules ou photos)

Techniques de lissages:
* Modèle de Gouraud
* Modèle de Phong

### Mip Mapping

Permet d'éviter la pixelisation lorsqu'on s'éloigne, et de sauvegarder de la mémoire: le niveau de détail des textures est adapté à la distance de l'objet.

### Textures procédurales

On génère certaines textures à la volée. Permet d'économiser la mémoire sans avoir de répétition dans les motifs.

Plusieurs techniques:
* pavages
* 'vagues' (avec des sinusoïdes)

Reste limité.

**Perlin noise** On peut faire mieux avec du bruit structuré: au lieu d'avoir en chaque point une valeur aléatoire (juste rand), on a un aléatoire progressif:

Pour obtenir ce résultat, on tire quelques points aléatoires, et on en déduit les autres par interpolation. Pour obtenir un aléatoire à plusieurs échelles, on répète ce processus avec un plus grand nombre de points aléatoires, et on fait la somme.

## Bump mapping

Si on veut donner un effet de volume sur une sphère (par exemple), on peut faire un maillage plus complexe qui les prend en compte. Mais c'est coûteux.

Une autre solution est d'appliquer des perturbations sur les normales, qui vont influer sur la façon dont la lumière va éclairer l'objets. C'est de la "triche", mais cela donne une forte impression de réalisme.

Les perturbations peuvent être aléatoires (bruit de perlin?) ou en fonction d'une texture.

**De manière générale** on peut ajouter des informations locales à des textures: déformation des normales, propriété des matériaux (comme le Kd/Ks).