# Physique et mathématiques visuelles/Comment filmer des flots 2D

Ce chapitre donne et explique un programme, écrit en C sharp, avec lequel il est possible de filmer des flots 2D.

### Le calcul des trajectoires

Un flot $\mathbf {f}$ dans le plan est une fonction de $\mathbb {R} ^{2}$ dans $\mathbb {R} ^{2}$. En chaque point du plan le vecteur vitesse du flot est défini.
Quand le flot est connu, le calcul d'une trajectoire à partir d'un point initial peut être très simple.
On choisit un intervalle de temps $dt$ petit et on calcule $x(t+dt)$ et $y(t+dt)$ à partir de $x(t)$ et $y(t)$ avec les formules :
$x(t+dt)=x(t)+f_{1}(x(t),y(t))dt$
$y(t+dt)=y(t)+f_{2}(x(t),y(t))dt$
où $f_{1}$ et $f_{2}$ sont les composantes de $\mathbf {f}$ c'est à dire que
$\mathbf {f} (x,y)=(f_{1}(x,y),f_{2}(x,y))$
( Mais pour améliorer la précision du calcul, et donc sa puissance, on a intérêt à se servir d'un meilleur algorithme. Celui de Runge-Kutta (présenté dans Blanchard, Devaney et Hall 2011) est particulièrement performant et a été adopté par ce programme dans la fonction R2 Go( int nstep, double t) dans le fichier R2.cs. )

### Le nuage de particules entraînées par le flot

Un flot transparent et vu de l'intérieur est aussi invisible que l'air. Il faut des nuages ou des poussières pour voir les écoulements.
Si on veut voir une seule ligne de courant, il suffit de créer des particules aléatoirement dans le temps mais toujours à la même place - on a supposé que le flot est stationnaire, c'est à dire qu'il ne varie pas dans le temps. Tout se passe comme si on déposait en permanence un peu d'encre en un point du flot qui l'entraîne.
Dans ce programme, les lignes de courant bleues sont issues d'une même ligne source (ou de plusieurs) qui peut être, mais pas nécessairement, le grand cercle qui entoure l'écran.
Pour visualiser le flot entre les lignes de courant, on crée également des particules noires réparties aléatoirement sur la ligne source.
Pour avoir un film périodique les particules sont recréées à la même place à intervalles de temps réguliers.

### Le dessin en haute définition

Pour dessiner des mouvements bien réguliers, il ne faut pas représenter les particules par des pixels ou des groupes de pixels, parce qu'on les verrait sauter de pixel en pixel.
Une particule est représentée par sa position - un vecteur dans $\mathbb {R} ^{2}$ - et on calcule la façon dont elle colore un pixel à partir de sa distance au centre du pixel. Il faut choisir une fonction qui est maximale pour une distance nulle et nulle pour une distance supérieure au rayon de la particule. En choisissant une forme en $\cos ^{4}$ par exemple on obtient une transition douce entre la coloration maximale et l'absence de coloration.
Dans $\mathbb {R} ^{2}$ un pixel est représenté non par un point mais par une surface carrée. Le pixel 0,0 par exemple, c'est à dire le pixel en haut à gauche, est le carré entre les points (0,0) et (1,1), il est donc centré en (0.5,0.5).

### Configuration requise

Je compile ce programme avec MonoDevelop dans Ubuntu (Linux) et et je me sers d'Image Magick pour l'assemblage d'une série d'images en un seul film.
Avec quelques adaptations ce programme devrait tourner dans n'importe quel environnement. Il suffit de créer des images Bitmap, de pouvoir les enregistrer en .gif, d'avoir les fonctions SetPixel, qui colore les pixels, et GetPixel, qui donne leur couleur présente, et quelques fonctions mathématiques habituelles : Sin, Cos, Sqrt...

### Comment assembler toutes les images en un seul film .gif

Le programme crée une série de 50 fichiers image, numérotés de Im100.gif à Im149.gif et les place dans un dossier Film qu'il faut avoir créé au préalable.
Image Magick permet d'assembler ces 50 images en un seul fichier de film .gif.
Si vous avez Ubuntu, Image Magick est déjà installé sur votre ordinateur.
Pour l'utiliser, il faut ouvrir un terminal (si vous ne savez pas faire, essayez Terminal avec l'onglet Chercher sur votre ordinateur en haut à gauche) puis se déplacer dans l'arborescence des dossiers pour trouver le dossier Film (essayez cette adresse si vous ne savez pas faire). Il faut alors écrire les trois lignes de code suivantes, chacune suivie d'une frappe de la touche Enter :
4 veut dire qu'il y a 4/100 de seconde entre chaque image, donc 25 images par seconde.
-loop 0 veut dire que le film tourne en boucle infinie. Pour n passages, il suffit de choisir -loop n.

### Tous les fichiers du programme

Pour compiler ce programme, vous devez rassembler tous les fichiers Program.cs, Film.cs, Calculate.cs, R2.cs, Draw.cs, Cloud.cs, Line.cs et LineSource.cs dans un seul projet (un console project avec Monodevelop).
.cs veut dire C sharp ou C#.

#### Le fichier de définition d'un film

L'en-tête donne les noms des paramètres qui servent à calculer un film.
La fonction R2 Flow(R2 v) est un flot 2D, c'est à dire une fonction de $\mathbb {R} ^{2}$ dans $\mathbb {R} ^{2}$
Ici elle est définie par Flow(x,y)=(x+y,y)
R2 est la classe des couples de réels.
Un nombre réel est un double pour la machine. Cela veut dire double précision, par opposition à la simple précision (le type float, nommé ainsi pour sa virgule flottante) qui n'est plus très utilisée.
int veut dire nombre entier (integer).
Le fichier Film.cs :

#### Le programme Main

Le fichier Program.cs :

#### Les autres fichiers

Le fichier Calculate.cs :
Le fichier R2.cs :
Le fichier Draw.cs :
Le fichier Cloud.cs :
Le fichier Line.cs :
Le fichier LineSource.cs :