Génération de champs à divergence nulle

publicité
Institut Supérieur
d'Informatique de
Modélisation et de
leurs Applications
Complexe des Cézeaux
63173 Aubière Cedex
Laboratoire de
Météorologie Physique
Complexe des Cézeaux
63173 Aubière Cedex
France
France
Rapport de projet de troisième année
Filière Calcul et Modélisation Scientiques
Génération de champs à divergence nulle
Application à la modélisation de nuages
Présenté par :
Responsables :
Aurélie Canale et Audrey Lemoussu
Albert Benassi et Jonas Koko
Durée : 120 heures
Soutenance : Mars 2008
Remerciements
Nous tenons à remercier Messieurs Albert Benassi et Jonas Koko pour leurs explications, leurs conseils, leur
disponibilité et leur soutien tout au long de ce projet.
Table des gures
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Structure d'un arbre . . . . . . . . . . . . . . . . . . . . . . . . . .
Représentation d'un espace 2D dans un arbre TdMAP . . . . . . .
Représentation d'un espace 3D dans un arbre TdMAP . . . . . . .
Localisation d'un point de l'espace 2D à l'aide d'un arbre TdMAP
Exemples de morphlettes en 1D . . . . . . . . . . . . . . . . . . . .
Contributions des diérents décalages de la morphlette en 2D . . .
Environnement Matlab . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
4
5
6
8
2.1 Structure de cellule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Représentation d'un Quadtree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1
3.2
3.3
3.4
3.5
Arbre de profondeur 3, H = 0,3333 . . . . . . . . . . . . . . . . . . . . . . . .
Arbre de profondeur 3, H = 0,5 . . . . . . . . . . . . . . . . . . . . . . . . . .
Arbre de profondeur 3, H = 0,3 après tirage de nouvelles variables aléatoires
Arbre de profondeur 5, H = 0,3333 . . . . . . . . . . . . . . . . . . . . . . . .
Arbre de profondeur 5, H = 0,5 . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
16
17
17
18
18
Résumé
Depuis quelques années, le LaMP (Laboratoire de Météorologie Physique) mène un grand projet dont l'objectif
principal est de trouver des algorithmes de faible complexité permettant de générer et d'animer des scènes complexes comme les nuages à l'aide de champs de vecteurs. L'une des nalités de ce projet est de pouvoir générer
des nuages, les éclairer et les animer en temps réel.
Notre travail a consisté à générer des nuages virtuels en utilisant le modèle TdMAP. Ce modèle représente
les diérentes couches d'un nuage dans un arbre à partir d'une simple fonction réelle, nulle aux bords et échantillonnée à chaque échelle sur l'espace considéré. La somme des contributions aux diérentes échelles, en un point
de l'espace, donne un vecteur. Grâce à ce modèle, il est possible de créer, avec une complexité en O(n.log(n)),
des champs de vecteurs multi-échelles à divergence nulle et possédant des propriétés physiques réalistes.
Nous avons implémenté le modèle TdMAP en C++. Pour rester proche de la structure du modèle, notre programme utilise également une structure en arbre : un quadtree pour les espaces bidimensionnels et un octree pour
les espaces tridimensionnels. Grâce à un facteur aléatoire, le programme peut générer plusieurs nuages à partir
d'un même arbre. Ceux-ci sont stockés dans des chiers texte, visualisables sous Matlab sous forme de champs de
vecteurs ou de lignes de courant. Seul le modèle bidimensionnel a été implémenté. Il apporte une amélioration en
terme de complexité et pourra facilement être généralisé aux autres dimensions.
Mots clefs : complexité, nuage, champ de vecteurs, modèle TdMAP, multi-échelle, arbre, divergence nulle.
Abstract
For few years, the LaMP (Laboratory of Physical Meteorology) has carried out a major project whose main
idea is to nd algorithms with a weak complexity which generate and animate complex scenes such as clouds
with vector elds. One of the nalities of this project is to be able to generate clouds, to light them and to
animate them in real-time.
Our work consists in the generation of virtual clouds using the TdMAP model. This model represents the
dierent scales of a cloud in a tree from a simple real function, null at the edges and sampled on the considered
space on each scale. The sum of all the contributions of each scale, at each point of space, results in a vector.
Thanks to this model, multi-scale vector elds with a null divergence and realistic physical properties can be
created with a O(n.log(n)) complexity.
We implemented the TdMAP model in C++. To stay close to the model structure, our program also uses a tree
structure : a quadtree for two-dimensional spaces and an octree for three-dimensional spaces. Using random vectors,
the program can generate many clouds from the same tree. These are stored in text les which can be visualized
with Matlab in the shape of vector elds or streamlines. Only the two-dimensional model has been implemented.
It improves the complexity and could be easily generalised to other dimensions.
Keywords: complexity, cloud, vector eld, TdMAP model, multi-scale, tree, null divergence.
Table des matières
Remerciements
Table des gures
Résumé
Abstract
Table des matières
Glossaire
Introduction
1 Contexte et Objectifs du projet
1.1 Le Laboratoire de Météorologie Physique
1.2 Le Modèle TdMAP vectoriel . . . . . . . .
1.2.1 La fonction Morphlette . . . . . .
1.2.2 Le paramètre de Hurst . . . . . . .
1.2.3 Le vecteur de décalage . . . . . . .
1.2.4 Le vecteur aléatoire . . . . . . . .
1.3 Problématique . . . . . . . . . . . . . . .
1.4 Les outils utilisés . . . . . . . . . . . . . .
1.4.1 Le langage C++ . . . . . . . . . .
1.4.2 Matlab . . . . . . . . . . . . . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2.1 Remarques générales . . . . . . . . . . . . . . . . . . . .
2.2 La structure d'arbre . . . . . . . . . . . . . . . . . . . .
2.2.1 Structures générales en dimension d . . . . . . .
2.2.2 Méthodes de la classe cellule et de la classe arbre
2.3 Morphlette . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 Vecteur aléatoire . . . . . . . . . . . . . . . . . . . . . .
2.5 Paramètre de Hurst . . . . . . . . . . . . . . . . . . . .
2.6 Visualisation sous Matlab . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Conception du modèle TdMAP
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
5
6
6
6
7
7
7
7
9
9
9
10
11
14
14
15
15
3 Résultats et discussion
16
Conclusion
21
3.1 Tests et résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Problèmes rencontrés et limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Améliorations possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Bibliographie
Annexes
Glossaire
Champ de vecteurs : construction qui associe un vecteur à chaque point de l'espace.
Complexité : théorie s'intéressant à l'étude formelle de la diculté des problèmes en informatique.
Divergence : opérateur qui rend compte de la variation innitésimale du volume (ou de la charge électrique)
autour d'un point et caractérise ainsi un écoulement de uide. La divergence d'un champ de vecteurs est un
scalaire et s'annule dans le cas de la conservation de matière. Dans un espace en 3 dimensions, la divergence de
F~ = F1 .~i + F2 .~j + F3 .~k est :
∂F1
∂F3
∂F3
div F~ = ∇.F~ =
+
+
∂x
∂y
∂z
Equations de Navier-Stokes : équations décrivant le mouvement des uides tels que les liquides ou les gaz et
décrites par Claude-Louis Navier et Georges Gabriel Stokes.
Multi-échelle : caractère d'un uide dont le comportement est invariant quelle que soit l'échelle considérée.
Octree : structure de données basée sur un arbre dont chacun des n÷uds possède 8 ls. Les octrees sont utilisés
pour partitionner un espace 3D, modélisé par un cube, en le subdivisant récursivement en 8 sous-cubes.
Quadtree : structure de données basée sur un arbre dont chacun des n÷uds possède 4 ls. Les quatrees sont utilisés
pour partitionner un espace 2D, modélisé par un carré, en le subdivisant récursivement en 4 carrés.
TdMAP : acronyme pour "Tree-Driven Mass Accumulation Process". C'est un modèle imaginé par le professeur
Albert Benassi visant à générer des champs turbulents.
Introduction
L'animation de scènes complexes est un enjeu considérable en physique et en infographie.
L'animation de nuages virtuels, en particulier, permettrait de répondre à de nombreuses demandes
provenant des militaires, des secteurs de l'audiovisuel (jeux vidéos, lms de synthèse, eets spéciaux. . . ) et de l'environnement (études d'impact, prévisions. . . ). Cependant, ces nuages doivent
être réalistes aussi bien visuellement que physiquement ce qui nécessite de générer une distribution
plausible de matière et de considérer son interaction avec le rayonnement solaire. On doit alors
modéliser les champs de vents, qui nous renseignent sur les déplacements et les déformations que
subissent les nuages, par des champs de vecteurs imitant des phénomènes turbulents.
À ce jour, des algorithmes existent pour générer des champs de vecteurs avec de bonnes propriétés physiques mais ils nécessitent de résoudre les équations de Navier-Stokes, ce qui demande
des ressources et des temps de calculs importants. La complexité de ces algorithmes est généralement en O(n2 ) et le traitement d'animations en temps réel est donc impossible. D'autres solutions
ont alors été envisagées.
C'est ainsi que le modèle TdMAP (Tree-Driven Mass Accumulation Process) a été inventé
par le professeur Albert Benassi et d'autres chercheurs du LaMP (Laboratoire de Météorologie
Physique). Les champs turbulents générés par ce modèle en arbre sont physiquement acceptables
et ont une divergence nulle an de satisfaire la loi de conservation de la matière au sein d'un
uide. L'intérêt principal de TdMAP est sa complexité en O(n.log(n)) surtout avantageuse pour
l'animation en temps réel.
Une version scalaire de ce modèle théorique a été programmée au cours d'un projet précédent
et donne de très bons résultats. Un stagiaire de Monsieur Benassi a également commencé à
programmer une version vectorielle mais la structure de données choisie, qui cherche à économiser
l'espace mémoire utilisé pour les calculs des champs de vecteurs, limite la manipulation des champs
et la liberté d'action que donnait le modèle théorique à l'utilisateur.
En raison de cette limitation et d'autres problèmes rencontrés, Monsieur Benassi proposa la
réalisation d'une autre version vectorielle de TdMAP avec une structure de données sous forme
d'arbre an de suivre le plus dèlement possible le modèle théorique. Notre projet a donc consisté
à réaliser cette nouvelle version de TdMAP.
Nous détaillerons dans un premier temps le modèle théorique TdMAP, puis nous nous intéresserons aux structures et aux méthodes utilisées pour l'implémentation du nouveau modèle
vectoriel. Enn, nous présenterons les résultats obtenus et discuterons des dicultés rencontrées
et des possibles améliorations.
A. Canale et A. Lemoussu
1
Chapitre 1
Contexte et Objectifs du projet
1.1
Le Laboratoire de Météorologie Physique
Le Laboratoire de Météorologie Physique (LaMP) est un laboratoire de l'Observatoire de Physique du Globe de Clermont-Ferrand (OPGC). Le thème général de recherche du LaMP concerne
l'impact des processus nuageux sur l'évolution du climat. Les sujets de recherche du laboratoire
sont divisés selon quatre thèmes principaux :
Nuages étendus et aérosols
Cycle de vie des nuages précipitants
Pollution : aérosols et nuages de la troposphère
Développement instrumental et expérimentation.
Monsieur Benassi fait parti du pôle "Cycle de vie des nuages précipitants" qui étudie les interactions entre les processus microphysiques et dynamiques des nuages et des précipitations. Les
recherches de cette équipe portent également sur la détermination des caractéristiques nuageuses
à partir de données satellitaires et aéroportées.
1.2
Le Modèle TdMAP vectoriel
Le modèle TdMAP pour Tree-driven Mass Accumulation Process possède une structure sous
forme d'arbre dont les n÷uds permettent de coder ecacement tout l'ensemble de l'espace, et ce
de façon bijective tout en respectant l'aspect multi-échelle d'un phénomène.
La gure 1.1 représente la structure d'un arbre. Un arbre est constitué de n÷uds reliées par des
branches. Chaque noeud a une structure de cellule qui contient diérents paramètres. La première
cellule de l'arbre est appelée la racine, c'est le niveau 0 de l'arbre. Chaque cellule possède un ou
plusieurs ls, sauf les cellules feuilles qui n'ont aucun ls, et un seul père, exceptée la racine de
l'arbre. Les ancêtres d'une cellule sont les cellules situées "au dessus" d'elle, c'est-à-dire la racine
et toutes les cellules intermédiaires qui permettent de joindre la racine à la cellule considérée en
passant par les branches de l'arbre. Les cellules sont également regroupées en niveaux, numérotés
de 0 à K, taille de l'arbre xée par l'utilisateur.
A. Canale et A. Lemoussu
2
Chapitre 1. Contexte et Objectifs du projet
Fig.
1.1 Structure d'un arbre
Pour représenter un espace bidimensionnel dans un arbre de type TdMAP, on divise l'espace,
modélisé par un carré, en quatre carrés numérotés de 0 à 3. Chaque sous-domaine créé correspond
à une branche du premier niveau de l'arbre. Le processus est ensuite réitéré sur les cellules créées.
Chaque subdivision de l'espace est donc modélisée par un n÷ud dans l'arbre : au niveau 0, l'unique
n÷ud correspond au domaine étudié en entier, le niveau 1 est composé de 4 n÷uds, le niveau 2
de 16 n÷uds, etc. (cf. gure 1.2)
Fig.
1.2 Représentation d'un espace bidimensionnel dans un arbre de type TdMAP [3]
En 3 dimensions, l'espace est représenté par un cube qui est divisé en 8 sous-cubes à chaque
niveau de l'arbre. On a donc 8 branches au niveau 1 de l'arbre, 64 au niveau 2, etc. (cf. gure 1.3).
Cette représentation de l'espace est généralisable aux espaces de dimension supérieure.
A. Canale et A. Lemoussu
3
Chapitre 1. Contexte et Objectifs du projet
Fig.
1.3 Représentation d'un espace 3D dans un arbre TdMAP [2]
La localisation d'un point dans l'espace est donc réalisée en parcourant une branche de l'arbre.
Pour faciliter la localisation, nous introduisons deux paramètres :
les niveaux dans l'arbre sont indexés par la valeur de j ,
les domaines pour un niveau j donné sont indexés sur les valeurs de k .
Prenons l'exemple d'un point situé dans le carré rouge représenté sur la gure 1.4 et déterminons les valeurs des paramètres j et k nécessaires pour modéliser la position de ce point dans un
arbre ayant 2 niveaux. Au premier niveau (j = 1), le point est situé entre 0 et 12 dans les deux
directions. Le paramètre k pour ce niveau est donc égal à 0. Au niveau suivant, on voit que le
point est entre 41 et 12 dans la direction horizontale et entre 0 et 14 dans la direction verticale, k
vaut donc 1 pour le niveau j = 2.
Fig.
1.4 Localisation d'un point de l'espace 2D à l'aide d'un arbre TdMAP
A. Canale et A. Lemoussu
4
Chapitre 1. Contexte et Objectifs du projet
Ainsi chaque point de l'espace est associé à une unique branche de l'arbre et la taille des cellules
du dernier niveau de l'arbre représente la précision nale des calculs.
En eet, chaque niveau de l'arbre représente un niveau de précision pour la représentation du
nuage. Au départ, niveau 0, la racine représente l'espace entier du nuage. Puis on descend d'un
étage en divisant l'espace en un nombre N de cellules, nombre qui dépend de la dimension dans
laquelle on travaille (N = 2dimension ). Chaque cellule est à son tour divisée en N cellules et ainsi
de suite. Donc plus on descend dans l'arbre, plus le nombre de cellules pour représenter un même
espace est grand, et plus la taille de chaque cellule est petite : on augmente donc en précision de
représentation.
Le but nal du modèle tdMAP est de parcourir l'ensemble d'étude et pour chaque cellule
élémentaire de l'arbre de calculer la valeur du champ en ce point. Pour ce faire, nous sommons
toutes les valeurs présentes en chacun des n÷uds de l'arbre que nous devons parcourir pour
atteindre le point courant.
La formule générale permettant de calculer le champ de vecteurs en un point x est la suivante :
X
ε
ε
(1.1)
X(x) =
2−jH .ϕ(2j x − k − ).Vj,k
2
j,k,ε
avec :
x point de l'espace de dimension d,
j profondeur dans l'arbre,
k numéro du n÷ud de l'arbre au niveau j ,
ϕ "morphlette", premier paramètre de masse,
H paramètre de Hurst, second paramètre de masse,
ε ∈ {0,1}d (avec ε 6= 1) vecteur de décalage dans un espace de dimension d,
ε
vecteur aléatoire, troisième paramètre de masse.
Vj,k
1.2.1 La fonction Morphlette
Une morphlette est une fonction nulle aux extrémités du domaine considéré et possédant un
unique maximum situé au centre du domaine. Cette fonction particulière permet d'engendrer
le champ de vecteurs recherché et sera échantillonnée et reproduite à chaque échelle de l'arbre
TdMAP.
Les fonctions de la gure 1.5 sont des exemples de morphlettes pour un espace unidimensionnel.
Fig.
A. Canale et A. Lemoussu
1.5 Exemples de morphlettes en 1D
5
Chapitre 1. Contexte et Objectifs du projet
1.2.2 Le paramètre de Hurst
Ce paramètre sert à atténuer l'amplitude de la morphlette pour les petites échelles (niveaux
j élevés). En eet, du niveau j au niveau j + 1, la taille des cellules est divisée par 2, mais
sans ce paramètre, l'amplitude est conservée, on a alors une accumulation d'énergie qui n'est pas
interprétable physiquement. Le paramètre de Hurst permet d'éviter ce phénomène.
1.2.3 Le vecteur de décalage
Nous avons vu précédemment que la morphlette était une fonction nulle aux bords, souséchantillonnée sur tout l'espace, ce qui génère des milieux avec des valeurs nulles aux bords des
sous-domaines. En réalité, les milieux ont rarement cette propriété.
Le professeur Benassi a alors imaginé une action de décalage multi-échelles permettant de
combler les "trous" laissés par la procédure du sous-échantillonnage de la morphlette. Pour un
espace en dimension 2, nous devons réaliser deux décalages de l'ordre de 12 : un selon l'axe des
abscisses et un selon l'axe des ordonnées (cf. gure 1.6).
Contributions des diérents décalages de la morphlette en 2D. En noir, le domaine
couvert par la morphlette initiale, en bleu, le décalage horizontal et en vert, le décalage vertical
de la morphlette. Les décalages permettent de couvrir l'ensemble du domaine et de supprimer les
valeurs nulles aux bords.
Fig.
1.6 Pour déterminer la valeur du vecteur en un point x de l'espace, on ajoute à la morphlette
initiale les valeurs des morphlettes correspondant aux décalages. Les contributions pour une cellule
x donnée sont de la forme :
1 0
1
2
−jH
0
2
.(ϕ(x).Vj,k + ϕ(x − 1 ).Vj,k + ϕ(x − 2 ).Vj,k
)
(1.2)
0
2
ε
vecteur aléatoire associé à :
avec Vj,k
la morphlette initiale si ε = 0,
la morphlette décalée horizontalement si ε = 1,
la morphlette décalée verticalement si ε = 2.
1.2.4 Le vecteur aléatoire
Pour notre problème, il est intéressant de pouvoir générer diérentes distributions de matière
sans changer les valeurs des diérents paramètre an de pouvoir étudier l'inuence de ces paramètres. La morphlette a donc été multipliée, en chaque n÷ud de l'arbre, par un vecteur aléatoire
dont la taille est la dimension de l'espace, ce qui permet de générer une innité de champs de
vecteurs à partir des mêmes paramètres. Dans le cas d'une morphlette décalée, le vecteur aléatoire
à prendre en compte dépend de la position du point x dans la cellule (cf. formule 1.2).
A. Canale et A. Lemoussu
6
Chapitre 1. Contexte et Objectifs du projet
1.3
Problématique
Une première version du modèle TdMAP vectoriel a été implémenté l'année dernière par Youness Gafa, stagiaire du professeur Benassi [4]. Youness Gafa a choisi une structure sous forme
de tableau qui contient les valeurs de la morphlette échantillonée sur tout l'espace considéré. Il
déduit ensuite les valeurs de la morphlette à tous les niveaux de l'arbre par un calcul. Ce procédé
a l'avantage d'économiser la mémoire utilisée mais limite la manipulation des champs de vecteurs
et la liberté d'action qu'ore la structure en arbre du modèle théorique.
De plus, les utilisateurs ont rencontrés quelques défauts dans le programme implémenté qui
empêchaient son utilisation optimale.
Nous devions donc implémenter une nouvelle version du modèle vectoriel avec une structure
en arbre an de bénécier de la modularité et du caractère multi-échelle de cette structure. Le
programme devait également respecter dèlement les particularités du modèle TdMAP théorique
et en particulier, sa complexité en O(n.log(n)).
1.4
Les outils utilisés
1.4.1 Le langage C++
Nous avons développé notre programme à l'aide du langage C++ qui est une version améliorée
du langage C. Son objectif de base est de permettre d'exprimer dans un langage proche du problème
à résoudre les concepts d'une solution. C'est un langage orienté objet qui ajoute au langage C
des fonctionnalités objet telles que l'encapsulation, l'héritage et le polymorphisme. Toutes les
fonctionnalités qu'apportaient le C sont renforcées par de nouvelles fonctionnalités et un grand
nombre de bibliothèques. Ce langage ore donc beaucoup de possibilités au programmeur. Il nous
sera ici utile pour l'utilisation d'une classe d'arbre et de méthodes associées.
1.4.2 Matlab
Pour visualiser les champs de vecteurs générés, nous avons utilisé le logiciel Matlab (gure 1.7).
Matlab est un puissant langage de programmation et de calcul numérique. Beaucoup de fonctions
mathématiques sont déjà implémentées et des boîtes à outils plus spéciques existent. Il permet
une manipulation facile des matrices, des traceurs et ajustements de courbes, l'implémentation
de vos propres algorithmes, la visualisation de données et l'interaction avec d'autres langages.
On peut écrire de simples scripts ou fonctions dans un chier appelé m-le et les lancer dans le
terminal.
A. Canale et A. Lemoussu
7
Chapitre 1. Contexte et Objectifs du projet
Fig.
A. Canale et A. Lemoussu
1.7 Environnement Matlab
8
Chapitre 2
Conception du modèle TdMAP
2.1
Remarques générales
La première étape de notre travail, qui fut relativement longue, consistait à comprendre le
modèle TdMAP et l'implémentation qu'avait réalisé Youness Gafa [5] an de déterminer les
fonctions utiles pour notre projet. Cependant, comme notre but était d'optimiser le programme
en utilisant une nouvelle structure pour modéliser le nuage, nous n'avons réutilisé que la classe
matrice qui permet la création et la manipulation des structures de base du modèle, à savoir les
matrices et les vecteurs.
Nous avons alors passé plusieurs semaines à rééchir à l'organisation de notre programme, aux
structures de données, paramètres, méthodes et fonctions nécessaires pour répondre aux objectifs
xés et décrits précédemment. Nous nous sommes basées sur une structure statique d'arbre, dont
les paramètres sont xés au départ par l'utilisateur, associée à un générateur de vecteurs aléatoires
qui permet de créer une innité de champs de vecteurs.
Dans un premier temps, nous avons travaillé sur des espaces bidimensionnels pour tester notre
modèle. Le passage aux espaces de dimension supérieure ne nécessite que quelques changements
au niveau de la structure et des calculs d'indices pour se répérer dans l'espace et n'est donc pas
trop compliqué.
Pour plus de détails, vous trouverez une documentation de notre programme en annexe B.
2.2
La structure d'arbre
Dans le but d'optimiser le programme du modèle TdMAP, nous devions revoir la structure
utilisée. Anciennement TdMAP utilisait des tableaux en 1 ou 2 dimensions ; pour nous, l'objectif
était de modéliser un nuage sous forme d'arbre. L'arbre est statique, c'est-à-dire que la structure
globale est construite au départ avec des paramètres xés et ne pourra être modiée.
Nous avons donc programmé la structure générale de l'arbre, ainsi qu'une structure de cellule
car un arbre est constitué de cellules, chaque cellule étant naturellement reliée à ses cellules ls.
Nous avions pensé à ajouter un lien frère qui relie chaque cellule à la cellule suivante pour un
niveau donné. Ainsi toutes les cellules d'un même niveau (et pas seulement les cellules ayant la
même cellule mère) sont reliées. Même si cela est compliqué à mettre en place lors de la construction
de l'arbre, une fois l'arbre construit, il est très facile et utile de se rendre à un niveau choisi et
de parcourir toutes les cellules d'un même niveau grâce à ces liens frère. Malheureusement nous
n'avons pas réussi à mettre tout ceci en place. En descendant dans l'arbre, de plus en plus de liens
frère manquaient et nous n'avons pas eu le temps de revenir sur cet algorithme qui s'est avéré plus
compliqué qu'il n'y paraissait.
A. Canale et A. Lemoussu
9
Chapitre 2. Conception du modèle TdMAP
2.2.1 Structures générales en dimension d
Structure de cellule
Chaque cellule possède les paramètres suivant (gure 2.1) :
val : vecteur de dimension d contenant la valeur de la morphlette en ce point précis de
l'espace.
alea : vecteur de dimension d contenant le vecteur aléatoire du noeud (chaque noeud à son
propre vecteur aléatoire).
tot : vecteur de dimension d comprenant la valeur calculée en ce point par le processus
d'accumulation de masse (formule 1.1).
brother : lien vers la cellule suivante au même niveau.
child : vecteur de dimension 2d contenant les liens vers les cellules ls.
ind : vecteur de taille d permettant de repérer la cellule dans l'espace (coordonnées du coin
inférieur gauche du carré que représente la cellule).
level : entier indiquant le niveau où se trouve la cellule dans l'arbre.
Fig.
2.1 Structure d'une cellule en dimension d
Structure d'arbre
Un arbre possède les paramètres suivant :
racine : pointeur sur une cellule. C'est le point de départ de l'arbre.
prof : entier indiquant la taille de l'arbre (la numérotation des niveaux commence à 0).
paramH : c'est le paramètre constant de Hurst, le H utilisé dans le terme 2−j.H de la formule
générale 1.1.
2D : Quadtree
Nous avons tout d'abord travaillé en dimension 2. On utilise donc un Quadtree (gure 2.2) :
de chaque noeud de l'arbre partent 4 branches. Chaque cellule de l'arbre a donc 4 ls. À un étage
k il y a 4k cellules. Une cellule représente un carré de l'espace et les points de l'espace ont 2
coordonnées.
Pour les tests et dans le but de généraliser plus rapidement au cas en 3 dimensions, nous avons
utilisé une morphlette sous la forme du matrice 3x3 qui génére des vecteurs en 3 dimensions. Mais
pour simplier la visualisation, nous ne nous intéressons qu'aux coordonnées x et y du vecteur
généré. Les vecteurs de la structure cellule sont donc en dimension 2 et possèdent 2 valeurs.
A. Canale et A. Lemoussu
10
Chapitre 2. Conception du modèle TdMAP
Structure d'un Quadtree de profondeur 2. En rouge sont représentés les liens frère
manquants dans la programmation.
Fig.
2.2 3D : Octree
Le principe est le même en 3 dimensions sauf que chaque cellule représente un cube de l'espace
et se divise en 8 sous-cubes. Chaque cellule de l'arbre a donc 8 ls. À un étage k il y a 8k cellules.
Les vecteurs de la structure cellule sont des vecteurs de dimension 3 ayant donc 3 valeurs. Une
cellule représente un cube de l'espace et les points de l'espace ont 3 coordonnées.
Nous n'avons nalement programmé que la version en dimension 2 par manque de temps
mais aussi car nous pensons qu'il serait préférable de programmer une classe générale d'arbre en
dimension N.
2.2.2 Méthodes de la classe cellule et de la classe arbre
Pour la structure d'arbre comme pour la structure de cellule, nous avons programmés les setteurs et getteurs qui nous paraissaient utiles. Ces méthodes nous permettent de récupérer et de
modier les paramètres de chaque structure.
L'arbre devenant vite complexe, nous utilisons la récursivité dans beaucoup de méthodes. Le
principe consiste à appeller une méthode sur l'arbre qui elle-même fait appel à une méthode
récursive s'appliquant sur des cellules. Cette méthode est donc appliquée sur la racine, puis sur
chacune des cellules ls de la racine, et ainsi de suite jusqu'à ce que le niveau des feuilles soit
atteint. Les méthodes récursives s'arrêtent grâce à un test sur la profondeur de l'arbre.
Construction de l'arbre
La méthode prend au minimum un paramètre qui est la profondeur de l'arbre. On peut éventuellement lui passer aussi le paramètre de Hurst. Cette méthode crée la cellule racine (en lui
attribuant ses valeurs val, alea, ind et level ), enregistre les paramètres important tels que la profondeur et le paramètre de Hurst. Puis elle appelle la méthode de construction récursive propre
aux cellules : celle-ci, appliquée à une cellule, lui crée 4 ls, remplit leurs paramètres et appelle à
nouveau la fonction construction récursive sur chacun d'eux.
A. Canale et A. Lemoussu
11
Chapitre 2. Conception du modèle TdMAP
Copie d'arbre et de cellule
Cette méthode surcharge "l'opérateur de copie =" et permet donc de créer la réplique d'un
arbre existant. Le principe est le même : la méthode de copie d'un arbre copie la racine, en utilisant
la méthode de copie de cellule, copie les paramètres importants puis appelle la méthode récursive
de copie sur la cellule racine. Celle-ci copie tous les ls de la racine et appelle à nouveau la méthode
de copie récursive sur chacun des ls de la racine. Et ainsi de suite jusqu'à ce que l'on atteigne le
niveau des feuilles.
La méthode de copie de cellule crée une nouvelle cellule, lui attribue les mêmes paramètres
que la cellule de départ : val, aléa, tot, ind, level ainsi que les liens frère et ls.
Processus d'accumulation local : Branche
Cette méthode sert à donner la valeur totale d'un point de l'espace selon le processus d'accumulation de masse (formule 1.1) c'est-à-dire que la valeur du point dont on passe les coordonnées
est égale à la valeur de la cellule représentant ce point à un niveau donné, à laquelle on ajoute les
valeurs de toutes ses cellules ancêtres.
Le principe est le suivant (cf. Algorithme de la méthode Branche, en annexe A) : on passe
en paramètre les coordonnées d'un point de l'espace et un niveau de précision, égal par défaut
à la profondeur totale de l'arbre. On parcourt l'arbre en partant de la racine, niveau par niveau
jusqu'au niveau de précision choisi. Sur chaque cellule, on calcule, en fonction des coordonnées du
point passé en paramètre, dans quelle branche il faut descendre. On somme les vecteurs val de
toutes les cellules rencontrées. On s'arrête au niveau de précision choisi.
Bien que nous n'ayons pas eu réellement besoin de cette fonction, elle peut être utile pour
calculer le champ de vecteurs en un point précis.
Processus d'accumulation de masse : totalSum
Cette méthode de la classe arbre permet de remplir les valeurs tot de chaque cellule de l'arbre.
C'est aussi une méthode récursive. L'idée était que chaque cellule ait son "champ total" tot qui
est le champ de vecteur présent en ce point de l'espace. Ce vecteur tient donc compte de tous ses
ancêtres et suit le processus d'accumulation de masse. Ainsi une fois les vecteurs tot de chaque
cellule calculés, il sut de se rendre à un niveau choisi, et de parcourir l'étage en utilisant les liens
frère pour récupérer les vecteurs des cellules du niveau, les écrire dans un chier texte et créer
l'image. On peut ensuite répéter facilement cette opération à diérents niveaux sans que cela ne
coûte en calcul puisque les vecteurs tot ont déjà été tous calculés. Cette méthode évite de calculer
et de parcourir plusieurs fois la même chose lors de la création de l'image. Bien entendu, si l'on
modie certains paramètres de l'arbre tels que le paramètre de Hurst ou les vecteurs aléatoires, il
faut rappeler la méthode totalSum pour réactualiser les vecteurs tot des cellules.
Nous avons eectivement programmé cette méthode, assez simple. On calcule tout d'abord la
valeur tot de la racine par la même formule que celle utilisée dans la méthode Branche :
totracine = valracine .alearacine .2−0.H
Ensuite on appelle la méthode sumRécursive de la classe cellule sur la racine en lui passant le
vecteur tot de la racine. Cette méthode calcule les vecteurs tot de chacun des ls de racine avec
la formule générale :
totcellule = totmere + valcellule .aleacellule .2−j.H
où j est le niveau de la cellule.
A. Canale et A. Lemoussu
12
Chapitre 2. Conception du modèle TdMAP
Puis elle appelle à nouveau la méthode récursive sumRécursive sur chaque ls, en passant en
paramètre leur vecteur tot (pour qu'elles soient ajoutées au vecteur propre des ls).
Malheureusement nous n'avons pas pu l'utiliser comme nous le souhaitions puisque nous
n'avons pas réussi à mettre en place tous les liens frère entre cellules d'un même niveau. Les
cellules n'étant pas bien reliées, nous ne pouvions donc plus parcourir facilement l'étage et la
méthode perd tout son intérêt. Nous avons donc changé de stratégie.
Calcul du champ de vecteurs : CreateTab
Pour pallier au problème rencontré avec la méthode totalSum, nous avons créé une nouvelle
méthode CreateTab qui calcule les valeurs des vecteurs en chaque point de l'espace avec une précision N , qui correspond à la profondeur de l'arbre créé. Cette méthode stocke au fur-et-à-mesure
les vecteurs calculés dans un tableau de taille 2N sur 2N qui couvre tout l'espace étudié.
La méthode CreateTab calcule tout d'abord le vecteur correspondant à la racine et initialise le
tableau avec ce vecteur car la racine couvre l'ensemble du domaine étudié. Elle appelle ensuite la
méthode récursive createTabRec qui calcule la valeur du vecteur pour la cellule considérée selon la
formule 1.2. Elle complète ensuite le tableau, à l'aide de la méthode RemplitTableau, en ajoutant
cette valeur aux valeurs déjà présentes dans le tableau et situées dans le domaine couvert par la
cellule. Enn, elle appelle à nouveau createTabRec sur chacun des ls de la cellule.
À la n du traitement, le tableau contient le champ de vecteurs de notre nuage avec une précision N . Pour le visualiser avec Matlab, nous devons encore générer le chier texte correspondant
au tableau.
L'inconvénient de cette méthode est que l'on doit refaire tous les calculs si l'on veut générer le
champ de vecteur avec une précision diérente, ce qui n'était pas le cas avec la méthode totalSum
utilisant les liens frère.
Creation du chier texte pour la visualisation sous Matlab : Nuage
La visualisation doit se faire sous Matlab en chargeant un chier texte contenant plusieurs
colonnes : une pour chaque coordonnée du point de l'espace (soit d colonnes en dimension d), et
une pour chaque valeurs du vecteur tot de ce point (encore d colonnes). La méthode nuage crée
ce chier texte.
Au départ, une fois l'arbre construit, on appelait la méthode totalSum pour remplir les vecteurs tot. Ensuite on appelait la méthode nuage. Il susait d'aller se placer à un niveau de
profondeur/précision choisi de l'arbre (cela se fait simplement en descendant le long de la branche
la plus à gauche de l'arbre). Une fois placé sur le début du niveau, on parcourait toutes les cellules
grâce aux liens frère, et l'on notait dans le chier texte, pour chaque cellule, les coordonnées du
point et les valeur du vecteur tot. Mais comme indiqué précédemment, les liens frère n'étant pas
bien mis en place nous avons dû procéder autrement.
Finalement la méthode nuage appelle la méthode createTab (voir paragraphe précédent), calcule les coordonnées des points et recopie dans un chier texte les valeurs des vecteurs en ces
points et stockées dans le tableau créé précédemment.
A. Canale et A. Lemoussu
13
Chapitre 2. Conception du modèle TdMAP
2.3
Morphlette
Dans un premier temps, nous avons travaillé dans un espace en 2 dimensions et généré des
vecteurs en 3 dimensions. La fonction ϕ de la formule 1.1 est donc une fonction matricielle de la
forme :


∂y2 F (X)
−∂x ∂y F (X)
0

0
∂x2 F (X)
ϕ(X) =  −∂y ∂x F (X)
2
2
0
0
(∂x + ∂y )F (X)
avec X = (x,y) un vecteur en dimension 2.
Pour la fonction F , nous avons choisi une fonction dont les dérivées partielles s'annulent aux
bords, c'est-à-dire lorsque x = 0 ou x = 1 ou y = 0 ou y = 1.
(1 − |X|2 )4 ∗ exp(−|X|2 ) si |X| < 1
F (X) =
0
sinon
Nous pouvons alors vérier que la divergence de ϕ(X) est nulle.
Pour les espaces en dimension 3, nous utilisons la même fonction F mais la matrice de la
morphlette est :

 2
−∂x ∂z F (X)
(∂y + ∂z2 )F (X) −∂x ∂y F (X)
ϕ(X) =  −∂y ∂x F (X) (∂x2 + ∂z2 )F (X) −∂y ∂z F (X) 
−∂z ∂x F (X)
−∂z ∂y F (X) (∂x2 + ∂y2 )F (X)
avec X = (x,y,z) un vecteur en dimension 3.
2.4
Vecteur aléatoire
Nous avions besoin d'un générateur de vecteurs aléatoires, de dimension 2 ou 3 et il était demandé qu'il suive une loi gaussienne centrée réduite. Deux étapes sont nécesaires pour le générer.
La première étape consiste à tirer un nombre aléatoire u selon une distribution uniforme sur
l'intervalle [0;1]. Nous utilisons la fonction du C++ rand qui génère un nombre pseudo-aléatoire
selon une distribution uniforme sur [0;Randmax ]. Nous ramenons cet intervalle à [0;1] en divisant
le nombre généré par Randmax .
La deuxième étape consiste à transformer ce nombre de la manière suivante :
u=
p
−2. log u. cos (2.π.u)
On obtient alors une loi gaussienne centrée réduite.
Lors de la construction de l'arbre, à chaque cellule, on eectue un tirage de d variables aléatoires (en dimension d) qui sont placées dans la variable alea de la cellule. Nous voulions avoir la
possibilité de générer plusieurs nuages sans avoir à refaire un arbre en entier. Nous avons donc créé
la méthode newAlea dans la classe arbre qui change les vecteurs alea de chaque cellule de l'arbre.
Ainsi il sut, après avoir appelé cette méthode, de relancer la méthode nuage puis la visualisation
pour voir apparaître un nouveau nuage.
A. Canale et A. Lemoussu
14
Chapitre 2. Conception du modèle TdMAP
2.5
Paramètre de Hurst
Il nous fallait aussi une fonction générant un paramètre de Hurst. Dans la formule générale du
processus d'accumulation de masse (formule 1.1), il apparaît dans le terme 2−j.H (j profondeur
dans l'arbre). H est une constante qui, pondérée par le niveau de précision j auquel on travaille,
va créér le paramètre de Hurst propre au niveau. Chaque niveau de l'arbre à donc une unique
valeur de Hurst égale à 2−niveau.H .
Nous utilisons donc un paramètre de Hurst H constant, choisit par l'utilisateur. Nous avons
programmé une fonction qui renvoyait directement le résultat du calcul du terme 2−j.H et qui est
utilisée à chaque niveau j de l'arbre pour le calcul des valeurs des cellules.
2.6
Visualisation sous Matlab
Il était demandé de faire la visualisation sous Matlab de manière simple. La méthode nuage
crée le chier texte contenant les données du nuage. Le chier texte est organisé, pour un travail
en 2 dimensions, selon 4 colonnes : x, y , cx, cy (en 3 dimensions il y aurait 6 colonnes, x, y , z , cx,
cy , cz ) où (x,y) sont les coordonnées du point, et (cx,cy) sont les coordonnées du vecteur en ce
point (calculé avec createTab ). Pour Matlab, x, y , cx et cy sont donc des vecteurs de taille 22N
avec N la profondeur de l'arbre.
Il est possible de créer à partir de ce chier texte diérents type d'images, notamment :
Une image représentant le champ de vecteurs. On utilise la fonction quiver(x,y,cx,cy) qui
trace en chaque point (x,y) le vecteur de composantes (cx,cy), sous forme de èche.
Une image représentant les lignes de courant. On utilise la fonction streamslice(X,Y,U,V )
avec X , Y , U et V les matrices de taille 2N sur 2N qui correspondent respectivement aux vecteurs x, y , cx et cy redimensionnés. Cette fonction trace les lignes de courant correspondant
au champ de vecteurs calculé.
Nous avons donc écrit une fonction Matlab visu qui prend en argument le nom du chier texte
et le nom du chier image où sera sauvé le résultat et qui applique les fonctions quiver et streamslice aux données.
A. Canale et A. Lemoussu
15
Chapitre 3
Résultats et discussion
3.1
Tests et résultats
Suite à la conception du programme, plusieurs tests ont été réalisés an de vérier que toutes
les méthodes de la classe arbre et de la classe cellule fonctionnaient correctement et donnaient les
résultats attendus.
Nous avons ensuite testé la génération de nuage avec diérents paramètres et diérents tirages
de vecteurs aléatoires. Pour chaque nuage généré et donc pour chaque chier texte créé, nous avons
généré deux images avec Matlab qui permettent de visualiser le nuage créé sous forme de champ
de vecteurs et de lignes de courant. Il est surtout intéressant de voir les changements engendrés
par la modication du paramètre de Hurst ou le choix de la profondeur (et donc de la précision
du nuage).
Génération de nuage avec un arbre de profondeur 3
La gure 3.1 représente un nuage généré à partir d'un arbre de profondeur 3 (l'espace est donc
divisé en 64 cellules représenté par une matrice 8x8), le paramètre de Hurst étant égal à 0,3333.
La première image représente le champ de vecteurs (sauvegardée au sein du programme Matlab)
et la deuxième représente les lignes de courant (copie d'écran).
3.1 Champ de vecteurs et lignes de courant pour un arbre de profondeur 3 et un paramètre
de Hurst égal à 0,3333
Fig.
A. Canale et A. Lemoussu
16
Chapitre 3. Résultats et discussion
La gure 3.2 représente le même nuage mais généré avec un paramètre de Hurst égal à 0,5. On
remarque que la direction générale du champ change sur chaque subdivision de l'espace.
3.2 Champ de vecteurs et lignes de courant pour un arbre de profondeur 3 et un paramètre
de Hurst égal à 0,5
Fig.
La gure 3.3 représente un nuage généré à partir du même arbre que celui de la gure 3.1
(profondeur 3, paramètre de Hurst égal à 0,3) mais après avoir eectué un tirage de nouvelles
variables aléatoires. On voit donc l'intérêt du facteur aléatoire pour générer plusieurs nuages à
partir d'un même arbre et donc à faible coût.
3.3 Champ de vecteurs et lignes de courant pour un arbre de profondeur 3 et un paramètre
de Hurst égal à 0,3 après un tirage de nouvelles variables aléatoires
Fig.
A. Canale et A. Lemoussu
17
Chapitre 3. Résultats et discussion
Génération de nuage avec un arbre de profondeur 5
La gure 3.4 représente un nuage généré à partir d'un arbre de profondeur 5 (l'espace est donc
divisé en 1024 cellules représenté par une matrice 32x32), le paramètre de Hurst étant égal à 0,3333.
Champ de vecteurs et lignes de courant pour un arbre de profondeur 5 et un paramètre
de Hurst égal à 0,3333
Fig.
3.4 La gure 3.5 représente le même nuage mais généré avec un paramètre de Hurst égal à 0,5.
Champ de vecteurs et lignes de courant pour un arbre de profondeur 5 et un paramètre
de Hurst égal à 0,5
Fig.
3.5 On remarque la subdivision de l'espace, surtout sur les images représentant les champs de
vecteurs. Ce phénomène est davantage marqué avec une profondeur de 3 puisque la précision des
calculs est moins grande. Les nuages obtenus avec un arbre de profondeur 5 sont plus précis et
semblent plus turbulents.
A. Canale et A. Lemoussu
18
Chapitre 3. Résultats et discussion
3.2
Problèmes rencontrés et limites
Plusieurs problèmes se sont posés à nous tout au long de ce projet, que ce soit sur la compréhension du modèle ou sur la conception d'une solution pour répondre aux problèmes posés par le sujet.
Tout d'abord, nous avons eu des dicultés à comprendre le modèle TdMAP et à reprendre le
code existant, malgré la documentation fournie avec le code. En eet, les concepts mis en jeu et
la structure choisie par Youness Gafa étaient assez complexes et il n'est jamais aisé de reprendre
un code que l'on n'a pas développé soi-même.
La représentation de l'espace par un arbre était également compliquée car plus on augmentait
en dimension ou en profondeur de l'arbre, plus la complexité augmentait rapidement. Nous nous
sommes retrouvés très vite avec des arbres très grands et complexes et il est devenu dicile de localiser une cellule particulière dans l'espace. En eet, en représentant l'espace sous forme d'arbre,
on perd la notion de voisin dans l'espace : deux cellules limitrophes dans l'espace réel ne seront pas
forcément proches dans un arbre. Elles n'auront peut-être pas la même cellule mère, et n'auront
peut-être pas non plus de lien frère entre elles. Il est donc parfois dicile dans l'arbre de retrouver
les voisins d'une cellule ce qui pose problème lorsque l'on travaille avec des morphlettes et que
l'on veut procéder à des décalages dans l'espace. Pour résoudre ce problème, nous avons alors
essayé diérents indiçages que nous avons placés en paramètre des fonctions puis nalement nous
avons choisi d'ajouter deux attributs à la classe cellule : level et ind. Ils permettent de localiser
précisement la cellule dans l'arbre et nécessitent peu de calculs.
De plus, comme expliqué dans le chapitre 2, nous voulions mettre en place un système de lien
frère entre les cellules du même niveau an de pouvoir parcourir facilement toutes les cellules d'un
niveau choisi. La construction récursive de l'arbre permet de lier les 4 ls d'une cellule avec le
pointeur frère, toutes les cellules du niveau 1 sont ainsi reliées entre elles, mais pour le niveau 2, il
manque les liens entre les "groupes" de ls. Nous devons alors remonter au niveau précédent pour
ajouter les liens manquant et ce, pour chaque groupe, comme le montre la gure 2.2 du chapitre 2.
Le problème devenant trop complexe, nous avons abandonné l'utilisation des liens frère et cherché
une autre solution.
Bien que la structure d'arbre fasse diminuer la complexité par rapport à l'ancienne structure,
elle reste complexe dès que l'arbre atteint une certaine taille. Notamment les fonctions récursives
peuvent devenir très lourdes puisqu'à l'étage k , en dimension d, la méthode récursive est appelée
sur les 2d ls des (2d )k cellules de l'étage.
Concernant l'utilisation de notre programme, pour l'instant, tout est xé dans le programme
principal main et la visualisation se fait manuellement : une fois le chier texte généré par le
programme C++, l'utilisateur doit se rendre sous Matlab et appeler la fonction visu pour le
visualiser. Rien ne lit le programme en C++ et Matlab. L'utilisateur doit donc comprendre un
minimum le code pour l'utiliser.
3.3
Améliorations possibles
La structure de la classe quadtree est xe pour le moment et nous pensions faire de même pour
les octree, une fois les méthodes testées sur les quadtree. Finalement, il semblerait plus intéressant d'implémenter une structure générale de Dtree (arbre en dimension D = 1,2,3 . . .) où chaque
cellule, exceptées les feuilles, aurait 2D ls (pour un QuadTree, D = 2 et un Octree, D = 3).
A. Canale et A. Lemoussu
19
Chapitre 3. Résultats et discussion
La plupart des méthodes de la classe quadtree sont facilement généralisables à la dimension D
puisqu'elles ne font intervenir la dimension de l'espace que pour le calcul des indices permettant
de localiser une cellule de l'arbre dans l'espace. Les cellules auraient pour paramètres des vecteurs de dimension D xe ou des éléments de la classe <vector> de la STL (Standard Template
Library), librairie spécique du langage C++, qui s'adaptent à toutes les dimensions d'espace.
Il surait donc simplement de demander à l'utilisateur de choisir la taille D de la structure au
début du programme et tout se ferait en fonction de cette dimension, de la construction à la visualisation. Il faudrait bien entendu choisir une fonction morphlette adaptée à la dimension choisie.
Concernant la visualisation, il serait intéressant de relier automatiquement le code C++ et
Matlab an d'éviter la création d'un chier texte et l'ouverture manuelle de Matlab.
Enn, pour rendre accessible le code à quiconque souhaite générer des nuages, il faudrait simplier sa manipulation, voire créer une petite interface où l'utilisateur n'aurait qu'à choisir la
dimension, le paramètre de Hurst, éventuellement la morphlette parmi plusieurs proposées et faire
autant de tirages de variables aléatoires et de visualisations qu'il le souhaite.
A. Canale et A. Lemoussu
20
Conclusion
Notre programme remplit aujourd'hui les conditions importantes que nous avions xées au
départ, à savoir générer des nuages avec une complexité en O(n.log(n)) en utilisant une structure
d'arbre proche du modèle TdMAP vectoriel théorique. Cependant, il ne répond qu'en partie aux
attentes du professeur Benassi puisque nous n'avons eu le temps d'implémenter que la version bidimensionnelle du modèle. En eet, nous avons passé plus de temps que prévu sur l'implémentation
des morphlettes et du concept de décalage en raison, notamment, de dicultés de compréhension
du modèle et de problèmes de localisation des cellules dans l'espace. Mais la plupart de nos dicultés ont été surmontées grâce l'aide de nos chefs de projet. Nous avons alors nalisé cette version
et visualisé les nuages créés qui se sont révélés être tout à fait satisfaisants.
La structure simple de notre modèle permettra de le généraliser facilement aux dimensions supérieures. Il pourra également être envisagé de compléter le programme avec les fonctions d'éclairement et d'animation en temps réel des nuages. Notre programme ore donc de bonnes perspectives,
surtout en terme de modèle de faible complexité.
A. Canale et A. Lemoussu
21
Bibliographie
[1] Simon Perreault's code : http://nomis80.org/code/octree.html .
[2] Wikipedia : http://fr.wikipedia.org/wiki/Octree .
[3] Rapport de projet. Gaignette E, Belballi W.
2007.
[4] Rapport de stage. Gafa Y.
[5] Programme de Gafa Y.
Génération de champs de vecteurs turbulents,
Création d'un générateur de densités, 2007.
Modèle TdMAP, 2007.
ANNEXES
Table des annexes
A Algorithme de la méthode Branche
B Documentation de code
i
iii
Algorithme de la méthode Branche
Annexe A
Algorithme de la méthode Branche
i
Algorithme de la méthode Branche
Fonction Branche( x1, x2 : double, precision : int) : vecteur 2 dimensions
[Initialisation:]
sum1, sum2, a1, a2 : entier;
temp : pointeur de cellule;
sum1 ← (racine->val1).(racine->alea1).2−0.H ; [ valeur de la racine selon x ]
sum2 ← (racine->val2).(racine->alea2).2−0.H ; [ valeur de la racine selon y ]
a1 ← x1; [ coordonnée du point courant selon x ]
a2 ← x2; [ coordonnée du point courant selon y ]
temp ← racine; [temp est un pointeur de cellule. Pointe sur le début de l'arbre ]
Pour ( int j = 1; j <= precision ; j++ ) faire
Si (a1 < 0.5) Alors
Si (a2 < 0.5) Alors
[ carre 1]
temp ← temp->child[1]; [ on descend dans la cellule ls 1]
[ ajustement des coordonnées du point courant par rapport à la cellule où l'on va ]
a1
a2
←
←
a1.2;
a2.2;
Sinon
[ carre 3]
temp ← temp->child[2]; [
on descend dans la cellule ls 3]
[ ajustement des coordonnées du point courant par rapport à la cellule où l'on va ]
a1
a2
←
←
a1.2;
(a2-0.5).2;
Fin Si
Sinon
Si (a2 < 0.5) Alors
[ carre 2 ]
temp = temp->child[1];
[ on descend dans la cellule ls 2]
[ ajustement des coordonnées du point courant par rapport à la cellule où l'on va ]
a1
a2
←
←
(a1-0.5).2;
a2.2;
Sinon
[ carre 4 ]
temp ← temp->child[3];
[ on descend dans la cellule ls 4]
[ ajustement des coordonnées du point courant par rapport à la cellule où l'on va ]
a1
a2
←
←
(a1-0.5).2;
(a2-0.5).2;
Fin Si
Fin Si
[une fois placé, actualisation du résultat ]
sum1
sum2
Fin
←
←
Fin Pour
Retourner
sum1 + (temp->val1).(temp->alea1).2−j.H ;
sum2 + (temp->val2).(temp->alea2).2−j.H ;
vecteur [sum1,sum2]
Algorithme 1: Algorithme de la méthode Branche de la classe arbre.
Paramètres :
-
x1 et x2 les coordonnées du point passé en paramètre.
precision la précision à laquelle on calcule la valeur en ce
sum1 valeur du vecteur résultat selon l'axe (Ox).
sum2 valeur du vecteur résultat selon l'axe (Oy).
ii
point.
Documentation de code
Annexe B
Documentation de code
iii
This document is created with trial version of HTML2PDF Pilot 2.15.72.
Main Page
Classes
Files
Class List
QuadCell Class Reference
#include <QuadTree.h>
Collaboration diagram for QuadCell:
Collaboration graph
[legend]
List of all members.
Public Member Functions
QuadCell & void void void void void void void QuadCell ()
operator= (const QuadCell &)
copieRec (const QuadCell u, int taille)
constRec (int taille)
destRec (const int taille)
newAleaRec (int taille)
totalSumRec (int taille, double h, double pere1, double pere2)
createTabRec (matrice < double * > *tab, int prof, double h)
RempliTableau (matrice < double * > *tab, double val[], int taille)
Friends
class QuadTree
Detailed Description
class QuadCell : classe cellule
Une cellule contient :






la valeur de la morphlette au point considéré,
la valeur du vecteur aléatoire
un tableau de 4 pointeurs sur les cellules fils.
un pointeur sur la cellule voisine
un tableau de deux indices situant la cellule dans l'espace
le niveau de la cellule dans l'arbre
Parameters:
val1 : morphlette appliquee a la coordonnee x
val2 : morphlette appliquee a la coordonnee y
alea1 : coordonnee selon x du vecteur aleatoire du noeud
alea2 : coordonnee selon y du vecteur aleatoire du noeud
child[4] : tableau contenant les pointeurs sur les fils
brother : pointeur sur la cellule suivante de l'étage (frère ou cousin)
ind : indices permettant de connaitre la position de la cellule ind[0] donne la coordonnée min selon la
direction x ind[1] donne la coordonnée min selon la direction y
level : niveau de la cellule dans l'arbre
Constructor & Destructor Documentation
QuadCell::QuadCell ( ) This document is created with trial version of HTML2PDF Pilot 2.15.72.
QuadCell : constructeur et destructeur de cellule
Member Function Documentation
QuadCell & QuadCell::operator= ( const QuadCell & u ) QuadCell operator de copie
Parameters:
u : la cellule a copier la cellule cree aura les memes parametres et valeurs de parametres que u
void QuadCell::copieRec ( const QuadCell u,
taille int )
copieRec : copie recursive de cellules de l arbre
Parameters:
u : taille de l'arbre restant a copier
taille : niveau dans l'arbre
Remarks:
: si taille == 0, fin, sinon copie des fils et application de la fonction a chaque fils. utilise la surcharge de
l'operateur =
void QuadCell::constRec ( int taille ) constRec : construction recursive de cellules
Parameters:
taille : taille de l'arbre restant a construire
Remarks:
: si taille == 0, fin, sinon creation des fils, attribution de leurs parametres et application de la fonction a chaque
fils
void QuadCell::destRec ( const int taille ) destRec : destruction recursive de cellules
Parameters:
taille : taille de l'arbre restant a detruire
void QuadCell::newAleaRec ( int taille ) newAleaRec : on tire une nouvelle variable aleatoire pour la cellule
Parameters:
taille : taille de l'arbre (ce qu'il reste a parcourir)
Remarks:
: associee a la methode de l'arbre newAlea.
This document is created with trial version of HTML2PDF Pilot 2.15.72.
void QuadCell::totalSumRec ( int double double double )
taille,
h,
pere1,
pere2 totalSumRec : calcul recursif du total en chaque point.
Parameters:
taille :
h :
pere1 :
pere2 :
profondeur de l arbre restant
parametre hurst de l arbre, pour prendre les valeur correspondante a l etage
valeur total des ancetres selon x
valeur total des ancetres selon y
Remarks:
: on ajoute a la cellule courante la valeur de ces ancetres, contenue dans pere_i
void QuadCell::createTabRec ( matrice < double * > * tab,
prof,
int h
double )
createTabRec : calcule recursif du tableau correspondant a l arbre
Parameters:
tab : tableau final contenant les valeurs du nuage, que l on remplit cellule apres cellule
prof : profondeur de l arbre
h,: parametre de Hurst
Remarks:
: sauf si la cellule est une feuille, on calcule la valeur de chacun des fils, on l ajoute au tableau, puis on
rappelle la methode recursive sur chaque fils
void QuadCell::RempliTableau ( matrice < double * > * tab,
val[],
double taille int )
RempliTableau : remplit le tableau final des champs de vecteurs calculés en chaque point de l'espace
Parameters:
tab : tableau de taille 2^N x 2^N avec N le nombre de niveaux
val : vecteur à ajouter au tableau
taille : taille du vecteur à ajouter au tableau
Remarks:
: on ajoute le vecteur val à toutes les cases du tableau comprises entre ind[0] et ind[0] + CellSize et entre ind
[1] et ind[1] + CellSize
The documentation for this class was generated from the following files:



Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree-1.h
Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree.h
Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree.cpp
This document is created with trial version of HTML2PDF Pilot 2.15.72.
Main Page
Classes
Files
Class List
QuadTree Class Reference
#include <QuadTree.h>
Collaboration diagram for QuadTree:
Collaboration graph
[legend]
List of all members.
Public Member Functions
QuadTree & void void void void matrice < double * > void QuadTree (int taille, double h)
operator= (const QuadTree &)
~QuadTree ()
newAlea ()
branche (double &sum1, double &sum2, double x1, double x2, int precision)
branche (double &sum1, double &sum2, double x1, double x2)
totalSum ()
createTab ()
nuage (char *file)
Detailed Description
QuadTree : classe d'arbre a 4 fils
contient un pointeur sur la racine, et un entier indiquant la profondeur (debute a 0)
Parameters:
racine : pointeur sur la cellule racine
prof : profondeur de l'arbre
paramH : parametre de Hurst. au niveau j on aura 2^(-j*paramH)
Constructor & Destructor Documentation
taille,
QuadTree::QuadTree ( int double h = 0.3333 )
QuadTree : construction d'un arbre
Parameters:
taille : taille de l'arbre (la racine est au niveau 0, il y a donc taille+1 niveaux)
h : parametre de Hurst, facultatif
Remarks:
: on cree la racine, lui attribue une valeur, et on lance la construction recursive sur cette racine. Par defaut, le
parametre Hurst est initialise a 0.3333 Pour le vecteur aleatoire, on suit une loi gaussienne centree reduite sur
[0 1]
QuadTree::~QuadTree ( ) This document is created with trial version of HTML2PDF Pilot 2.15.72.
QuadTree : destruction d'un arbre
Member Function Documentation
QuadTree & QuadTree::operator= ( const QuadTree & u ) QuadTree operator = : surcharge de l'opérateur =
Parameters:
u : arbre a copier arbre2 = arbre : arbre2 aura la même taille, les mêmes paramètres et les mêmes valeurs
que arbre
Remarks:
: on copie la racine et les parametres de l arbre, puis on appelle la methode copieRec sur racine : va copier
recursivement toutes les cellules de l arbre
void QuadTree::newAlea ( ) newAlea : faire un nouveau tirage de valeur pour la fonction de densite de l'arbre
Remarks:
: fonction qui appelle la fonction recursive newAleaRec : sur chaque cellule on tire une nouvelle variable
aleatoire selon x et y
void QuadTree::branche ( double & sum1,
double & sum2,
x1,
double x2,
double precision int )
branche : calcule de la valeur du point de coordonnees x1, x2
Parameters:
x1 : coordonnee du point selon x
x2 : coordonnee du point selon y
sum1 : valeur total du point selon x
sum2 : valeur total du point selon y
: precision : niveau de precision pour le calcul. par defaut, precision = profondeur
Remarks:
: on somme toutes les valeurs des cellules de la branche correspondant
void QuadTree::branche ( double & sum1,
double & sum2,
x1,
double x2
double )
branche : calcule de la valeur du point de coordonnees x1, x2
Parameters:
x1 : coordonnee du point selon x
This document
withdu
trial
version
x2 is :created
coordonnee
point
selon of
y HTML2PDF Pilot 2.15.72.
sum1 : valeur total du point selon x
sum2 : valeur total du point selon y
Remarks:
: ici precision n'etant pas precise, l'arbre est parcouru sur toute sa hauteur on somme toutes les valeurs de la
branche correspondant
void QuadTree::totalSum ( ) totalSum : attribue a chaque cellule la somme des valeurs de ses ancêtres plus la sienne
Remarks:
: cette valeur globale est mise dans les parametres tot1 et tot2, l un selon x, l autre selon y ainsi pour connaitre
les valeurs de point a un certain niveau de precision, il suffira de parcourir les valeurs des cellules de l etage.
necessite un parcours total, comme celui de la construction
matrice < double * > QuadTree::createTab ( ) createTab : cree le tableau global des valeurs de l arbre
Returns:
: tableau final contenant les valeurs du nuage, que l on remplit recursivement
Remarks:
: on calcule la valeur vect de la racine, on rempli le tableau avec, puis on appelle la methode recursive
createTabRec sur la cellule racine en lui passant les parametres necessaires (notamment le tableau)
void QuadTree::nuage ( char * file ) nuage : ecrit dans un fichier texte les valeurs du nuage
Parameters:
file : nom du fichier texte ou ecrire les donnees
Remarks:
si file n'existe pas, il est créé. format : premiere colonne coordonnee x du point, deuxieme colonne coordonnee
y du point, colonnes suivantes coordonnee x et y du champ de vecteur en ce point.
The documentation for this class was generated from the following files:



Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree-1.h
Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree.h
Mes documents/Isima/cours/Troisieme année/projet/code/QuadTree.cpp
Generated on Wed Mar 12 19:00:37 2008 for TdMAP by 1.5.1
This document is created with trial version of HTML2PDF Pilot 2.15.72.
Main Page
File List
Classes
Files
File Members
Mes documents/Isima/cours/Troisieme année/projet/code/calcul.h
File Reference
#include "math.h"
#include "matrice.h"
Include dependency graph for calcul.h:
This graph shows which files directly or indirectly include this file:
Functions
template<typename T>
T norm2 (matrice < T > &X)
template<typename T>
T df2 (matrice < T > &X, int dir1=0, int dir2=0)
template<typename T>
matrice < T > CalculMorphlette (int dim, matrice < T > &X)
Detailed Description
Calcul de la matrice de la morphlette en un point donné
Remarks:
: Morphlette choisie : f(X) = (1 - |X|²)^4 * exp (-|X|²) si |X|<1 = 0 sinon
Function Documentation
template<typename T>
dim,
matrice <T> CalculMorphlette ( int matrice < T > & X
)
calculMorphlette : calcul la valeur de la morphlette en un point donné
Parameters:
dim : dimension de l'espace d'arrivée = dimension du champs de vecteurs
X : point de l'espace (vecteur)
Remarks:
: On ne s'intéresse qu'aux champs de vecteurs de dimension 3 donc dim = 3
template<typename T>
T df2 ( matrice < T > & X,
dir1 = 0,
int dir2 = 0 int This document
is created with trial version of HTML2PDF Pilot 2.15.72.
)
df2 : calcul la dérivée seconde de la fonction
Parameters:
X : point de calcul
dir1 : direction de la dérivée première
dir2 : direction de la dériée seconde
Remarks:
: X est un vecteur en dimension 1, 2 ou 3 Directions des dérivées : 1 pour x, 2 pour y, 3 pour z
template<typename T>
T norm2 ( matrice < T > & X ) norm2 : calcul le carré de la norme euclidienne d'un vecteur
Parameters:
X : vecteur à normer
Generated on Wed Mar 12 19:00:36 2008 for TdMAP by 1.5.1
This document is created with trial version of HTML2PDF Pilot 2.15.72.
Main Page
File List
Classes
Files
File Members
Mes documents/Isima/cours/Troisieme
année/projet/code/paramHurst.cpp File Reference
#include "math.h"
Include dependency graph for paramHurst.cpp:
Functions
double hurst (int niveau, double parametreH)
Detailed Description
Déclaration de la fonction de calcul du paramètre de Hurst
Function Documentation
niveau ,
double hurst ( int double parametreH )
hurst : calcul du facteur de hurst global
Parameters:
niveau : niveau j ou l'on calcule le parametre
parametreH : parametre de Hurst
Returns:
: 2^(-niveau*H)
Generated on Wed Mar 12 19:00:36 2008 for TdMAP by 1.5.1
This document is created with trial version of HTML2PDF Pilot 2.15.72.
Main Page
File List
Classes
Files
File Members
Mes documents/Isima/cours/Troisieme
année/projet/code/densite.cpp File Reference
#include "math.h"
#include <ctime>
#include <string>
Include dependency graph for densite.cpp:
Functions
double * randN ()
Detailed Description
Calcul des vecteurs aléatoires
Remarks:
: suit une loi gaussienne centree reduite sur [0 1].
Function Documentation
double* randN ( ) randN : generateur de vecteur aleatoire 2D
Returns:
: vecteur 2 dimensions contenant 2 nombres pseudo-aleatoires
Remarks:
: suit une loi gaussienne centree reduite sur [0 1]. attention : pour l'independance des tirages, penser a
initialiser le generateur, avec srand par exemple.
Generated on Wed Mar 12 19:00:36 2008 for TdMAP by 1.5.1
Téléchargement