Rapport

Transcription

Rapport

Institut Supérieur
d’Informatique de
Modélisation et de
leurs Applications
Complexe des Cézeaux
63173 Aubière Cedex
France
Projet de 2ème année
Option : Calcul et Modélisation Scientifiques
Interface graphique MATLAB
de génération de surfaces pour le maillage 2D
Présenté par :
Chef de projet :
Guillaume BOUSQUET
Caroline FRITEYRE
Jonas KOKO
Soutenance :
lundi 23 mars 2009
Remerciements
Nous tenons à remercier M. Jonas KOKO pour sa disponibilité et son aide durant la conception de
projet. Nous remercions aussi Mme Murielle MOUZAT pour son aide quant à la rédaction de ce rapport.
Table des figures
1.1
1.2
1.3
1.4
1.5
Exemple d’un maillage triangulaire . . . . .
Exemple d’utilisation de MATLAB . . . . .
Création d’une nouvelle interface graphique
Réglage des paramètres de composants . . .
Génération automatique du fichier .m . . .
2.1
2.2
2.3
2.4
2.5
2.6
Interface graphique de résolution d’un système matriciel . . . . .
Interface graphique permettant de tracer une fonction entre deux
Déplacement du curseur sur le cadre pour sélectionner un point .
Interface finale pour la définition de surface . . . . . . . . . . . .
Représentation de la surface définie par l’utilisateur . . . . . . .
Enregistrement de la surface définie par l’utilisateur . . . . . . .
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
3
4
5
5
. . . .
bornes
. . . .
. . . .
. . . .
. . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
10
12
15
15
16
Résumé
Le logiciel MATLAB possède une interface nommée PDETOOL permettant de créer des surfaces
dans le cadre de résolution de problèmes d’équations aux dérivées partielles. Pour complèter la résolution,
le logiciel propose aussi des fonctions permettant de mailler ces surfaces. Toutefois, le maillage du logiciel
est assez sommaire donc peu précis dans le cadre d’études mathématiques approfondies.
Notre travail a consisté à créer une interface graphique pouvant générer des surfaces à deux
dimensions à partir du langage de programmation MATLAB. Cette interface a pour but de fournir à
l’utilisateur un ensemble de points dans un fichier de type .dat lui permettant de regénérer la surface et
de lui appliquer d’autres maillages que celui proposé par le logiciel.
A partir du logiciel GUI fourni par MATLAB, nous avons créé plusieurs interfaces dont la principale
répond au problème posé. Nous avons procédé par étapes afin d’améliorer à chaque interface la facilité
d’utilisation et la gestion des erreurs. Seule l’interface finale a été optimisée pour l’utilisation. Nous
nous sommes servis uniquement du langage de programmation MATLAB et des cours de géométrie et
d’analyse numérique pour résoudre les problèmes mathématiques de ce projet.
Mots clefs : MATLAB, maillage, surface, ellipse, rectangle, GUI.
Abstract
The software package MATLAB provides an interface named PDETOOL which enables the
user to create surfaces for the resolution of partial differential equations. To complete the resolution,
MATLAB also proposes function enabling to mesh those surfaces. However, the meshing of the software
package is basic, so little precise for applied mathematical studies.
Our work consisted in creating a graphical interface which can generate 2-D surfaces from the
programming language MATLAB. With this interface, the user can define a set of points in a file of type
.dat which enables him to generate the surface again et apply to it other meshings than the one included
in the software package.
From the software package GUI provided by MATLAB, we have created several interfaces, the main
one of which answers the given problem. We have proceeded by steps so as to improve each time the
ease of use and the ruling of the errors. Only the final interface has been optimized for use. We used
the programming language MATLAB and courses of Geometry and Numerical Analysis to solve the
problems of this project.
Keywords: MATLAB, mesh, surface, ellipse, rectangle, GUI.
Table des matières
Remerciements
Table des figures
Résumé
Abstract
Table des matières
Glossaire
Introduction
1 Objectifs et outils
1.1 Le maillage en mathématiques .
1.2 MATLAB . . . . . . . . . . . . .
1.3 Problématique et objectifs . . . .
1.4 Outils utilisés . . . . . . . . . . .
1.4.1 L’interface graphique sous
1.4.2 Rectangles et ellipses . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
3
4
4
6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
8
8
9
10
10
11
11
12
12
13
14
3 Résultats et discussions
3.1 Problèmes rencontrés et limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Améliorations possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
17
18
Conclusion
19
. . . . . .
. . . . . .
. . . . . .
. . . . . .
MATLAB
. . . . . .
2 Conception de l’interface graphique 2-D
2.1 La résolution matricielle . . . . . . . . .
2.1.1 Théorie mathématique . . . . . .
2.1.2 Interface mise en place . . . . . .
2.2 La lecture de fonction . . . . . . . . . .
2.2.1 Lecture d’une fonction saisie . .
2.2.2 Représentation graphique . . . .
2.3 La lecture de surface . . . . . . . . . . .
2.3.1 La fonction ginput . . . . . . . .
2.3.2 La saisie de coordonnées . . . . .
2.3.3 La définition de la surface . . . .
2.3.4 L’interface finale . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Bibliographie
ANNEXES
A Extraits du code source de la lecture et de la représentation graphique d’une fonction
B Extraits du code source de l’interface de définition de surface
5
I
III
Glossaire
Surface : Une surface désigne une couche fermée d’un objet, la surface est utilisée pour sa propriété
d’être fermée, donc d’aire finie.
Déterminant : Notion d’algèbre permettant le calcul de plusieurs objets mathématiques comme
les valeurs propres et servant à la résolution de systèmes d’équations linéaires.
Interface Graphique : Partie visible d’un logiciel dont se sert l’utilisateur.
GUI : De l’anglais Graphical User Interface, programme lié à MATLAB permettant la génération d’interface graphique pour les fonctions développées avec le langage MATLAB.
Introduction
Le maillage est une technique mathématique ayant pour but de modéliser des
conditions réelles appliquées à des objets virtuels. Par exemple, dans la construction d’un
avion, une longue phase de calculs informatiques modélisant la résistance de l’avion à
l’air est nécessaire pour construire un prototype dont on est sûr qu’il volera correctement
dès son lancement. Dans ce genre de cas, le maillage sert à décomposer la surface de
l’avion où va s’écouler l’air afin de pouvoir étudier cet écoulement le plus précisément
possible sur chaque petite partie de la carlingue.
Il existe de multiples techniques de maillages. Mais le logiciel MATLAB n’en possède
qu’une dans son catalogue de fonctions. Or, celle-ci s’avère être plutôt sommaire car
composée uniquement de triangles. M. Jonas KOKO a fait développer de nouvelles
fonctions permettant un maillage plus précis des surfaces considérées. Toutefois, il s’avère
qu’il n’existe aucun programme interne au logiciel MATLAB permettant de réaliser
des surfaces et de les enregistrer pour pouvoir les appliquer aux nouvelles fonctions de
maillage.
Pour résoudre ce problème, M. KOKO nous a proposé de réaliser une interface
graphique permettant la création de surfaces à partir de formes simples comme les ellipses
et les rectangles, puis la modification de ces surfaces et enfin leurs enregistrements. Notre
projet a donc consisté à créer cette interface.
Nous détaillerons dans un premier temps les outils que nous avons utilisés pour ce
projet, ainsi que les objectifs précis que nous avons voulu atteindre, puis nous nous intéresserons aux différentes versions d’interfaces que nous avons créées, et principalement
sur l’interface répondant au problème posé. Enfin, nous verrons quels sont les principaux
problèmes auxquels nous avons été confrontés, les limites de notre interface et les options
possibles d’évolutions.
Guillaume BOUSQUET et Caroline FRITEYRE
1
Chapitre 1
Objectifs et outils
1.1
Le maillage en mathématiques
En mathématiques, le maillage est la discrétisation spatiale d’un milieu continu, ou
aussi la modélisation géométrique d’un domaine aux éléments proportionnés fini et bien
défini.
Fig. 1.1: Exemple d’un maillage triangulaire
Le but du maillage est de permettre à celui qui l’utilise de résoudre un problème de
type Méthode des Eléments Finis pour résoudre des Equations aux Dérivées Partielles.
Pour cela, l’utilisateur se sert d’un maillage qu’il choisit afin de découper le domaine en
un nombre fini de composantes géométriques (triangles, carrés...) dont les propriétés
mathématiques sont connues par l’utilisateur. Ainsi, l’utilisateur n’a plus qu’à s’occuper
de résoudre le problème posé pour un nombre fini de surfaces simples pour obtenir la
résolution finale du problème posé.
1.2
MATLAB
MATLAB est un nom désignant à la fois un langage de programmation et un
environnement de développement, qui a été développé et commercialisé par l’entreprise
américaine The MathWork. MATLAB est très utilisé à la fois dans la recherche et
2
Chapitre 1. Objectifs et outils
l’industrie, mais aussi dans l’éducation, les calculs numériques et le développement de
projets.
Fig. 1.2: Exemple d’utilisation de MATLAB
Le langage MATLAB permet de modéliser et de résoudre des problèmes mathématiques complexes que de simples calculatrices ne peuvent résoudre. La dernière version
développée par la compagnie est la 7.08. Ce logiciel est très utilisé dans le milieu
ingénieur par sa facilité de prise en main, son interface graphique très bien construite et
son environnement interactif. Avec MATLAB, on peut aussi bien résoudre des problèmes
de mathématiques abstraites, que modéliser des phénomènes physiques bien particuliers.
Par exemple, MATLAB est un logiciel très utilisé dans l’industrie aéronautique pour
modéliser des souffleries afin de tester les avions.
1.3
Problématique et objectifs
Le logiciel MATLAB dispose d’un système de maillage à deux dimensions de type
triangulaire. Toutefois, ce maillage est assez sommaire et il n’est pas possible d’utiliser
d’autres maillages, souvent plus complexes et surtout plus précis dans les calculs.
Le but de ce projet est donc de résoudre le problème suivant : peut-on créer une
interface graphique permettant de modéliser des surfaces en deux dimensions, pour
ensuite pouvoir mailler ces mêmes surfaces ?
Notre tuteur de projet, M. Jonas KOKO, a déjà en sa possession des fonctions permettant des maillages plus précis des surfaces. Nous avons donc concentré notre travail
sur la création de la surface permettant la création, puis la récupération de surfaces auxiliaires afin que celles-ci puissent être maillées. Pour cela, nous avons procédé par étapes.
3
Tout d’abord en réalisant une interface pour la résolution matricielle de problème (voir
figure 2.1). Puis pour l’affichage de fonctions (voir figure 2.2). Enfin pour l’affichage, la
modification et l’enregistrement des surfaces (voir figure 2.4).
1.4
1.4.1
Outils utilisés
L’interface graphique sous MATLAB
Création du fichier .f ig
MATLAB possède l’outil GUIDE, qui permet de créer facilement des interfaces
graphiques. Il suffit pour cela de taper dans la ligne de commande de MATLAB guide
et on a alors accès à ses différentes fonctions. On peut entre autres créer une interface
graphique à partir de modèles déjà existants, d’interfaces sauvegardées ou en créer depuis
le début, ce que nous avons fait.
Pour chaque nouvelle interface créée, nous avons dû réfléchir aux différentes composantes dont nous avions besoin (champs d’affichage simples, champs où l’utilisateur
peut écrire, boutons, panneaux d’affichage, etc) et les mettre en place en les sélectionnant
dans la liste de composants située à gauche de la fenêtre et en déplaçant sur l’interface à
créer (voir figure 1.3).
Fig. 1.3: Création d’une nouvelle interface graphique
Une fois tous les composants mis en place, il a fallu leur définir des valeurs par défaut.
Par exemple, pour les champs où l’utilisateur peut entrer des données, il a fallu indiquer
ce qu’ils affichent au départ, lorsque l’utilisateur n’a encore rien entré. On peut également
choisir, entre autres, la taille, la couleur et la position d’un composant donné.
Enfin, on sauvegarde le tout en un fichier avec l’extension .f ig.
4
Fig. 1.4: Réglage des paramètres de composants
Création du fichier .m correspondant
Une fois les différents composants de l’interface graphique mis en place, il faut
les faire interagir, c’est-à-dire, programmer l’interface graphique. GUIDE permet la
génération automatique d’un fichier .m correspondant à un fichier .f ig. Celui-ci contient
notamment une fonction s’exécutant au lancement du programme et les appels aux
différents composants.
Fig. 1.5: Génération automatique du fichier .m
Le principal de notre travail a consisté à écrire les fonctions de rétroaction relatives aux
boutons, c’est-à-dire les instructions à exécuter lorsque l’utilisateur clique sur un bouton
donné.
5
1.4.2
Rectangles et ellipses
Détermination d’une ellipse
Afin de définir une ellipse, deux méthodes différentes ont été mises en oeuvre :
• la première consiste en la saisie de trois points dont le premier est considéré comme
le centre,
• la seconde nécessite la détermination du rectangle englobant.
On rappelle que l’équation d’une ellipse en coordonnées cartésiennes est la suivante :
(x − x0 )2 (y − y0 )2
+
=1
a2
b2
(1.1)
où
• (x0 , y0 ) est le centre de l’ellipse,
• a, le demi-grand axe,
• b, le demi-petit axe.
Détermination d’une ellipse à partir de trois points
Il est possible de définir une ellipse à partir de trois points. On considère que le premier
point (x0 , y0 ) est le centre de l’ellipse et que les deux autres points (x1 , y1 ) et (x2 , y2 ) se
situent sur le contour de l’ellipse. On cherche alors à déterminer son demi-grand axe a et
son demi-petit axe b. On obtient, d’après l’équation 1.1, le système suivant :
( (x −x )2
1
0
a2
(x2 −x0 )2
a2
+
+
(y1 −y0 )2
b2
(y2 −y0 )2
b2
=1
=1
que l’on peut réécrire sous la forme Au = v avec
A=
(x1 − x0 )2 (y1 − y0 )2
(x2 − x0 )2 (y2 − y0 )2
!
, u=
a0
b0
!
et v =
1
1
!
avec
a0 =
1
1
et b0 = 2
2
a
b
Deux cas se présentent alors :
• Si la matrice A n’est pas inversible, il est alors impossible de déterminer une conique.
• Sinon, il est possible de trouver le vecteur u, solution de l’équation initiale Au = v.
On doit alors trouver les valeurs de a et b. Ceci n’est possible que si les composantes
a0 et b0 du vecteur u sont toutes les deux strictement positives. (Dans le cas contraire,
on pourrait déterminer une hyperbole.) On obtient alors
1
1
a= √
et b = √
a02
b02
6
Détermination d’une ellipse à partir de deux points
Une autre méthode consiste à définir le rectangle englobant de l’ellipse. Pour définir
un rectangle, on se donne deux sommets opposés de coordonnées (x1 , y1 ) et (x2 , y2 ). On
obtient alors facilement la longueur (horizontale) L = |x1 − x2 | et la hauteur (verticale)
H = |y1 − y2 |.
Fonction rectangle
Afin de tracer des rectangles et des ellipses, nous avons fait appel à la fonction
rectangle dont le prototype est le suivant :
(’Position’,[x,y,l,h],’Curvature’,[cx,cy],’LineWidth’,e,’LineStyle’,’-’)
où
• x et y définissent les coordonnées du point inférieur gauche
• l et h définissent les longueurs selon les axes respectifs des abscisses et des ordonnées
• cx = cy = 0 pour un rectangle et cx = cy = 1 pour une ellipse
• e désigne l’épaisseur du trait
• 0 −0 indique que l’on veut un contour continu
7
Chapitre 2
Conception de l’interface graphique
2-D
2.1
2.1.1
La résolution matricielle
Théorie mathématique
La résolution matricielle d’un problème consiste tout d’abord à réécrire le problème
sous la forme d’un système matriciel afin de pouvoir s’inscrire dans la théorie d’Analyse
Numérique Matricielle. Cette forme est la suivante :



a1,1 . . . a1,p
 .

.. 


Ax=B avec A =  ..
. 
, x = 
an,1 . . . an,p


x1

.. 

. 
 et B = 
xn

b1
.. 
. 

bn
où x est la solution recherchée. Il s’agit d’un calcul matriciel simple mais qui nécessite
certaines vérifications. En effet, la manière la plus simple de résoudre ce système est de
faire comme s’il s’agissait d’une simple multiplication : si Ax = B alors
x=
B
A
Dans les multiplications simples, pour que cela soit vrai, il suffit que le nombre A soit
différent de 0. Dans le cadre du calcul matriciel, il faut que lamatrice A soit
 inversible,
1 ... 0
 .
.. 
c’est-à-dire qu’il existe une matrice B telle que AB=BA=In = 
. 
 ..
.
0 ... 1
Si une telle matrice existe, alors cette matrice B est égale à A-1 . La manière la plus
facile de vérifier si une telle matrice A est inversible est de calculer son déterminant. Pour
qu’une matrice soit inversible, il suffit que son déterminant soit non nul. MATLAB possède
une fonction qui permet de calculer automatiquement le déterminant d’une fonction, ainsi
que de calculer directement x=B/A sans avoir besoin de calculer la matrice inverse de A.
Le déterminant d’une matrice A est généralement calculé comme étant le produit des
valeurs propres de la matrice, donc si aucune de ses valeurs propres n’est nulle, on sait
que la déterminant sera non nul.
8
Chapitre 2. Conception de l’interface graphique 2-D
2.1.2
Interface mise en place
Afin de débuter notre projet, et pour commencer notre apprentissage de construction
de fenêtres graphiques sous MATLAB, nous avons élaboré un système simple de résolution
de système matriciel Ax=B. L’interface est simple, elle comporte trois fenêtres à remplir,
une fenêtre résultat et une fenêtre remarque dans le cas où il y aurait un problème.
L’algorithme utilisé pour cet interface est le suivant :
Programme 1 Résolution matricielle
n <- lire(dimension) ;
A <- lire(matrice A) ;
B <- lire(vecteur B) ;
si A et B sont cohérents avec la dimension donné par n
alors
si Déterminant de A non nul
alors
Calcul de x <- B/A ;
Retourner x ;
sinon
Afficher ("erreur dans matrice A") ;
fin si
sinon
Afficher ("erreur dans la dimension") ;
fin si
Fig. 2.1: Interface graphique de résolution d’un système matriciel
9
L’utilisateur commence par entrer la dimension du problème, c’est-à-dire le nombre de
lignes et de colonnes que la matrice A devra avoir, ainsi que le nombre de lignes qu’auront
les vecteurs x et b. Puis il rentre la matrice A et le vecteur b. En appyant sur le bouton
Résoudre, le logiciel MATLAB calcule le vecteur x solution. S’il n’y a aucune solution
possible, la fenêtre remarque affiche deux possibilités :
• soit l’utilisateur a entré une matrice A non inversible,
• soit la matrice A ou le vecteur b qui ont été écrits ne correspondent pas à la dimension
donnée par n.
Sinon le programme affiche le vecteur résultat.
2.2
2.2.1
La lecture de fonction
Lecture d’une fonction saisie
Nous avons créé une interface graphique qui permet d’afficher la représentation
graphique d’une fonction f : R → R entre deux abscisses Xmin et Xmax différentes,
comme cela nous est montré sur la figure 2.2.
Fig. 2.2: Interface graphique permettant de tracer une fonction entre deux bornes
Outre Xmin et Xmax , il a fallu récupérer la chaı̂ne de caractères donnant l’expression
de f (x) et l’appeler en des valeurs particulières. Se pose alors le problème de l’obtention
de la valeur f (a) à partir de la chaı̂ne de caractères et de la valeur a. Nous avons, pour
cela, utilisé cet algorithme décrit ci-dessous.
Il s’agit en fait de créer une nouvelle chaı̂ne de caractères à partir de la chaı̂ne initiale
où les x sont remplacés par (a), en faisant attention à ce qu’il ne s’agisse de x du terme
exp. Ensuite, on demande à la fonction eval d’évaluer cette nouvelle chaı̂ne représentant
une expression mathématique.
10
Programme 2 fonction transformation
On place dans une cha^
ıne de caractères la fonction écrite par l’utilisateur ;
tant qu’on n’a pas parcouru toute la cha^
ıne faire
si on tombe sur un ’x’
alors
si on n’est pas en fin de cha^
ıne
alors
si le suivant n’est pas un ’p’
alors
% Il ne s’agit pas d’une exponentielle
On concatène le ’x’ de la cha^
ıne dans la fonction comme étant une variable
de la fonction finale ;
sinon
on écrit le ’x’ classique de la fonction exponentielle dans la
cha^
ıne finale ;
fin si
sinon
On concatène le ’x’ de la cha^
ıne comme étant une variable de la fonction
finale ;
fin si
sinon
% Ce n’est pas un ’x’.
On écrit la lettre classique dans la fonction finale ;
fin si
fait
On retourne la fonction ;
2.2.2
Représentation graphique
Pour représenter la fonction entre Xmin et Xmax , nous avons besoin d’un tableau de
valeurs d’abscisses x et d’un tableau de valeurs d’ordonnées y. Nous avons donc appliquer
l’algorithme suivant :
Programme 3 Affichage de la représentation graphique de f
Gr^
ace au pas et à l’intervalle des abscisses, on définit toutes les abscisses ;
tant qu’on n’a pas parcouru toutes les abscisses x
On calcule f(x) où f est la fonction déterminée en 2.2.1 ;
fait
On représente tous les f(x) en fonction des x sur le graphe ;
2.3
La lecture de surface
Au final, nous avons dû réaliser une interface graphique permettant de représenter
une zone définie par l’utilisateur à l’aide de rectangles et d’ellipses.
11
2.3.1
La fonction ginput
Afin de définir les rectangles et ellipses, nous avons utilisé la fonction ginput qui prend
en argument le nombre de points à récupérer. Aussi, pour un rectangle, nous avons utilisé
l’instruction ginput(2) et, pour une ellipse, ginput(3). Lors de l’exécution du programme,
l’utilisateur a, selon son choix, défini au préalable en cliquant sur Tracer un rectangle ou
Tracer une ellipse, deux ou trois points à définir en cliquant avec le curseur sur le cadre
affichant les figures (voir figure 2.3).
Fig. 2.3: Déplacement du curseur sur le cadre pour sélectionner un point
2.3.2
La saisie de coordonnées
Il s’est ensuite avéré que cette façon de procéder n’était pas judicieuse car on manquait
de précision. En effet, il était difficile de cliquer sur un point précis avec le curseur. Aussi
avons-nous dû abandonner la fonction ginput pour des champs de valeurs à renseigner.
Nous avons alors décidé de nous servir directement de la saisie de coordonnées par
l’utilisateur dans des cases prévues à cet effet. Nous avons tout d’abord rajouté clairement
des emplacements pour que l’utilisateur puissent modifier les axes comme il le souhaite,
afin de rendre sa surface plus ou moins grande dans la fenêtre d’affichage. Ensuite, nous
avons décidé de donner la possibilité à l’utilisateur de se servir de coordonnées propres
aux rectangles et de coordonnées propres aux ellipses, c’est-à-dire définir deux points
pour le rectangle et trois points pour l’ellipse. Mais pour l’ellipse, un double problème
se pose. Tout d’abord, l’utilisateur doit donner des points très précis se trouvant sur
l’ellipse, ce qui est difficile, s’il n’a qu’une idée approximative de là où se situe le contour
de l’ellipse. De plus, comme nous l’avons vu dans la partie 1.4.2, le calcul est plus
compliqué à effectuer donc il y a risque de ralentir le programme.
Après discussion avec notre chef de projet, nous avons décidé de faire une interface
unique de saisie de coordonnées, de deux points définissant un rectangle, où ensuite
12
l’utilisateur peut choisir de tracer le rectangle ou bien l’ellipse contenue dans ce rectangle.
2.3.3
La définition de la surface
Lorsque l’utilisateur demande à tracer un rectangle ou une ellipse, le programme
garde les coordonnées en mémoire et affiche dans un cadre la liste des figures présentes.
S’il a tracé deux rectangles puis une ellipse puis un rectangle puis une ellipse, la chaı̂ne de
caractères ’R1+R2+E1+R3+E2’ s’affiche alors par défaut dans le cadre situé à gauche du
bouton. Cette chaı̂ne définit la surface considérée, à savoir ici l’union de toutes les figures.
L’utilisateur peut modifier à sa guide cette chaı̂ne afin de définir sa propore surface à
afficher. Par exemple, la chaı̂ne ’R2-E1+R1’ définie la surface contenue à l’intérieur du
deuxième rectangle à laquelle a été enlevée la surface définie à l’intérieur de la première
ellipse à laquelle a ensuite été rajoutée la surface contenue à l’intérieur du premier rectangle. Des surfaces peuvent ainsi être enlevées et rajoutées au fur et à mesure de la lecture
de la chaı̂ne.
Nous avons ensuite dû mettre en place une fonction récoltant les données permettant
de traduire cette chaı̂ne en ensembles à ajouter et ôter. Cette dernière prend en entrée la
chaı̂ne de caractères et renvoie une structure dont les lignes correspondent aux différents
ensembles, la première colonne correspondant à l’appartenance ou non des points de la
surface considérée à cet ensemble, la deuxième, à la nature de la figure (rectangle ou
ellipse) et la troisième, à son numéro.
Programme 4 fonction récoltant les données
On initialise le vecteur des figures comme étant nul.
si la cha^
ıne est non vide
alors
si le caractère de début n’est pas un ’-’
alors
On rajoute un ’+’ au début de la cha^
ıne ;
fin si
tant qu’on n’a pas parcouru toute la cha^
ıne
On récupère le prochain bloc codant un signe, un caractère et un nombre
et on les stocke dans une structure à la suite du vecteur;
fait
fin si
Retourner le vecteur des figures ;
Enfin, on a dû écrire une fonction appartient qui indique si un point (x, y) donné
appartient ou non à la surface considérée. Pour cela, on part de la fin de la structure
donnees - qui correspond à la traduction de la chaı̂ne entrée par l’utilisateur. Tant que
l’on ne trouve pas une figure dans laquelle se trouve un point considéré, on passe à la
figure précédente. S’il s’avère que le point n’appartient à aucune des figures, on considère
qu’il n’appartient pas à la surface définie.
13
Programme 5 fonction déterminant les points de la surface finale
On récupère la matrice des figures définies à partir de la cha^
ıne
entrée par l’utilisateur ;
si elle est vide
alors
On indique que l’utilisateur n’a pas défini de surface ;
sinon
pour chaque point du cadre
tant que non stop et qu’on n’a pas parcouru toute la matrice de figures
% en partant de la fin de la matrice
si le point appartient à la figure
alors
si le signe de la figure est ’+’
alors
on l’affiche ;
fin si
stop ;
fin si
fait
fait
fin si
2.3.4
L’interface finale
Une fois le projet terminé, nous avons décidé de construire une dernière interface
graphique plus simple d’utilisation ainsi qu’un système de sauvegarde de la surface et de
nettoyage de la mémoire pour éviter à l’utilisateur de devoir fermer et ouvrir à nouveau
l’interface pour l’utiliser.
L’utilisateur entre donc les axes, autant de surfaces qu’il souhaite, puis dans le champ
sous la figure, détermine la surface qu’il souhaite mailler. Après avoir cliqué sur Tracer la
surface, il voit se dessiner la surface à mailler. Pour représenter cette surface, on se sert
de l’ensemble des points qui composent cette surface. Pour chaque point, on trace un
petit rectangle de manière à noircir la surface finale, et donc fait clairement apparaı̂tre la
surface déterminée par l’utilisateur.
Si cette surface ne convient pas à l’utilisateur, il peut modifier la surface à tracer et
cliquer à nouveau sur le bouton Tracer la surface, de même s’il souhaite reprendre son
travail à zéro, il lui suffit de cliquer sur le bouton Tout effacer qui videra la mémoire
occupée, et effacera la figure tracée. Mais si la surface lui convient, il lui suffit alors de
cliquer sur le bouton Enregistrez la surface, qui ouvrira une petite fenêtre lui proposant
d’enregistrer l’ensemble des points appartennant à la surface dans un fichier de type .mat
sous le nom et le répertoire qu’il souhaite. Une fois cela effectué, il n’aura plus qu’à faire
passer ce fichier par les fonctions de maillage qu’il aura choisies pour obtenir le maillage
de la surface.
14
Fig. 2.4: Interface finale pour la définition de surface
Fig. 2.5: Représentation de la surface définie par l’utilisateur
15
Fig. 2.6: Enregistrement de la surface définie par l’utilisateur
16
Chapitre 3
Résultats et discussions
3.1
Problèmes rencontrés et limites
Tout au long de ce projet, nous avons dû très souvent faire face à des problèmes liés
d’une part à la théorie mathématique mais aussi aux possibilités du logiciel MATLAB.
Comme nous l’avons vu précédemment, tracer une ellipse peut se faire de plusieurs façons
qui n’ont ni le même temps de calcul ni la même précision. De même, notre projet ne
traitait pas du maillage à deux dimensions spécifiquement, mais de la manière d’obtenir
des surfaces à mailler.
Les principaux problèmes que nous avons rencontrés et les solutions que nous avons
construites sont les suivants :
• le temps de traçage des surfaces simples (rectangles et ellipses),
• le temps de calcul des surfaces définies par l’utilisateur,
• la gestion des erreurs dans le cas des ellipses,
• l’enregistrement des données,
• le nettoyage de la mémoire.
Comme expliqué dans le paragraphe 2.3.2, nous avons préféré saisir les ellipses à partir
des rectangles les contenant. Cela facilite le temps de calcul et diminue la complexité du
calcul, mais oblige l’utilisateur à savoir dans quel rectangle l’ellipse se situe, c’est-à-dire
connaı̂tre le centre de l’ellipse, ainsi que son petit et grand axe. Ainsi, un utilisateur qui
ne connaı̂t que trois points placés sur l’ellipse ne pourra pas la tracer. Cela permet aussi
de ne plus se soucier des erreurs dues à de mauvaises coordonnées. En effet, lorsque les
coordonnées des trois points sont entrées, elles peuvent définir soit une ellipse, soit une
hyperbole, soit aucune des deux. La seule erreur à prendre en compte est alors la mauvaise
entrée de points vis-à-vis des axes prédéfinis.
De la même manière, le temps de calcul des surfaces est soumis à conditions. Nous
délimitons un ensemble de points appartenant à toutes les surfaces tracées, puis nous
vérifions point par point s’ils appartiennent ou non à la surface définie par l’utilisateur.
Le principal problème est alors le temps de calcul de l’appartennance ou non des points
à la surface. Plus le nombre de points est élevé, plus le temps de calcul est long. Mais
pour obtenir une surface correctement définie afin d’obtenir un bon maillage, nous devons
fournir un maximum de points dans la surface. Le temps de calcul est la principale limite
de l’interface finale.
17
Chapitre 3. Résultats et discussions
Enfin le dernier problème que nous avons rencontré est celui de la mémoire. En effet
lorsque l’utilisateur souhaitait définir deux surfaces, il devait fermer et relancer l’interface
entre chaque étape. Nous avons décidé de mettre en place le bouton Tout effacer (voir
partie 2.3.4). Mais une fois que l’utilisateur appuie sur le bouton, il ne peut plus revenir
en arrière et récupérer les données qu’il avait entrées. Il doit donc être sûr de ne plus
avoir besoin de celles-ci avant de cliquer sur le bouton.
3.2
Améliorations possibles
Ce projet, bien que terminé, peut être amélioré. Nous avons d’ailleurs créé un fichier
executable afin de se servir de l’interface sans avoir besoin de lancer MATLAB. Toutefois,
cet exécutable ne se lance correctement que sous les systèmes d’exploitation Windows
XP/Vista. Une première amélioration pourrait donc être de créer un exécutable pour
les système Linux/Unix/Mac.
Une autre amélioration possible est celui de l’insertion du maillage dans l’interface
graphique. En effet, nous n’avons pas maillé les surfaces. L’utilisateur se sert de notre
projet pour définir sa surface puis passe le fichier résultat par les fonctions de maillage.
Nous avons pensé à regrouper notre programme et les fonctions, mais après discussion
avec notre chef de projet, il s’est avéré que lier les deux peut présenter de forts risques
de provoquer une panne du programme à cause d’un trop grand temps de calcul. Une
amélioration pourrait être de revoir la structure de calcul du programme et de la rendre
compatible avec les fonctions de maillages, afin de rendre possible la création d’un programme unique définissant la surface et le maillage au sein d’une même fenêtre graphique.
Mais la plus grosse évolution possible de ce programme pourrait être celle de la définition des surfaces. En effet, d’une part, l’utilisateur n’a que des ellipses et des rectangles
à sa disposition pour définir sa surface, et il doit uniquement jouer avec des intersections
et des unions pour définir la surface à mailler. La première évolution pourrait être de
permettre à l’utilisateur d’avoir à sa disposition d’autres formes géométriques prédéfinies
(triangles, quadrilatères sans propriétés...) ou alors de lui faire définir une surface fermée
par autant de côtés qu’il le souhaite grâce à un système de traits tracés les uns à la suite
des autres, un peu comme dans le logiciel paint sous Windows. D’autre part, une autre
évolution possible serait de permettre de sélectionner à la souris les zones définissant la
surface, afin que l’utilisateur n’ait pas à se poser la question de savoir si les unions et les
intersections prennent bien en compte les surfaces souhaitées.
18
Conclusion
Notre interface remplit aujourd’hui les conditions que nous avions fixées au départ,
à savoir générer des surfaces fermées à partir de composantes simples, et permettre
l’enregistrement d’un nombre significatif de points contenus dans ces surfaces dans des
fichiers de type .mat. Toutefois, il existe plusieurs possibilités d’améliorations, notamment
sur le plan du maillage, puisque le projet n’a pas pu être directement rattaché aux
fonctions de maillages de M. KOKO. La structure simple de notre programme permettra
de modifier facilement le contenu pour inclure les fonctions de maillages directement dans
l’interface.
Grâce à ce projet, nous avons pu découvrir une grande partie du logiciel MATLAB que
nous n’avons pu voir en cours par manque de temps. Ce projet nous a appris à prendre
en compte l’ergonomie d’un programme, et de se placer du point de vue d’un utilisateur
n’ayant pas de connaissances particulières en géométrie et en analyse numérique.
Bibliographie
[1] Cours d’Analyse Numérique, ISIMA 1ère année. Koko J, Barra V, Mahey F. Analyse
Numérique Matricielle et Optimisation.
[2] Cours de Logiciel Numérique, ISIMA 2ème année. Koko J. Cours de Logiciel
Numérique: MATLAB.
[3] Site officiel de MATLAB: http://www.mathworks.fr/.
[4] The MathWorks.MATLAB: Creating Graphical User Interfaces.
[5] Per-Olof Persson and Gilbert Strang DistMesh - A Simple Mesh Generator in MATLAB Department of Mathematics at Masachusetts Institute of Technology. 2005.
http://www-math.mit.edu/ persson/mesh/
ANNEXES
Annexe A
Extraits du code source de la lecture
et de la représentation graphique
d’une fonction
Programme 6 Récupération des abscisses et de la chaı̂ne entrée par l’utilisateur
function bouton_tracer_Callback(hObject, eventdata, handles)
hold on
x1 = str2double(get(handles.Xmin, ’string’)) ;
x2 = str2double(get(handles.Xmax, ’string’)) ;
p=abs(x2-x1)/500 ;
% Définition du pas d’avancement
x=x1:p:x2 ;
% Détermination de l’intervalle
% On récupère la fonction entrée par l’utilisateur.
chaine = get(handles.fonction_a_tracer, ’string’) ;
Chapitre A. Extraits du code source de la lecture et de la représentation graphique
d’une fonction
Programme 7 Evaluation de la fonction
for parcours=1:length(x)
chaine_transformee = ’’ ;
l = 0 ;
for k = 1:length(chaine)
if chaine(k) == ’x’
if k<length(chaine)
% On n’est pas en bout de cha^
ıne.
if chaine(k+1)~= ’p’
% Il ne s’agit pas d’un "exp".
valeur_chaine = num2str(x(parcours)) ;
l = l + length(valeur_chaine) + 2 ;
chaine_transformee = strcat(chaine_transformee, ’(’) ;
chaine_transformee = strcat(chaine_transformee, valeur_chaine) ;
chaine_transformee = strcat(chaine_transformee, ’)’) ;
else
% Il s’agit d’un "exp".
l = l + 1 ;
chaine_transformee(l) = chaine(k) ;
end
else
% Il s’agit d’un "x" en bout de cha^
ıne.
valeur_chaine = num2str(x(parcours)) ;
l = l + length(valeur_chaine) + 2 ;
chaine_transformee = strcat(chaine_transformee, ’(’) ;
chaine_transformee = strcat(chaine_transformee, valeur_chaine) ;
chaine_transformee = strcat(chaine_transformee, ’)’) ;
end
else
% Ce n’est pas un x.
l = l + 1 ;
chaine_transformee(l) = chaine(k) ;
end
end
y(parcours) = eval(chaine_transformee) ; % calcul de la valeur de y
end
Programme 8 Représentation graphique de la fonction
%Graphe de la fonction y(x)
axes(handles.graphe)
plot(x,y)
II
Annexe B
Extraits du code source de l’interface
de définition de surface
Programme 9 Réglage des axes
% booleen -> 1 -> c’est bon
%
2 -> c’est pas bon
function booleen = reglage_axes(h)
booleen = false ;
[Xmin,Xmax,Ymin,Ymax] = coordonnees(h) ;
if isnan(Xmin) | isnan(Xmax) | isnan(Ymin) | isnan(Ymax)
nb_messages = nb_messages + 1 ;
set(h.texte_message, ’string’,...
[’erreur nř’ num2str(nb_messages) ’ :...
Xmin, Xmax, Ymin ou Ymax incorrects (== NaN)’]) ;
else
booleen = ~(Xmin >= Xmax || Ymin >= Ymax) ;
if ~booleen
set(h.texte_message, ’string’,...
[’erreur nř’num2str(nb_messages)’: Xmin >= Xmax ou Ymin >= Ymax’]) ;
else
axis([Xmin Xmax Ymin Ymax]) ;
end
end
Chapitre B. Extraits du code source de l’interface de définition de surface
Programme 10 Tracé d’un rectangle
function bouton_rectangle_Callback(hObject, eventdata, handles)
e = 1 ;
% epaisseur du trait
if reglage_axes(handles)
x1_rect = str2double(traitement(get(handles.x1_rect,
x2_rect = str2double(traitement(get(handles.x2_rect,
y1_rect = str2double(traitement(get(handles.y1_rect,
y2_rect = str2double(traitement(get(handles.y2_rect,
’String’)))
’String’)))
’String’)))
’String’)))
;
;
;
;
if isnan(x1_rect) | isnan(x2_rect) | isnan(y1_rect) | isnan(y2_rect)
set(handles.texte_message, ’string’,...
[’erreur nř’num2str(nb_messages)’:coordonnees du rectangle invalides’]);
else
L = abs(x2_rect - x1_rect) ;
% cotes paralleles a l’axe des abscisses
H = abs(y2_rect - y1_rect) ;
% cotes paralleles a l’axe des ordonnees
X = min(x1_rect, x2_rect) ;
% [X,Y] sommet du triangle en bas a gauche
Y = min(y1_rect, y2_rect) ;
if L == 0 |H == 0
[’erreur nř’ num2str(nb_messages) ’ : L <= 0 ou H <= 0’]) ;
else
rectangle(’Position’,[X,Y,L,H], ’Curvature’,[0,0],...
’LineWidth’,e,’LineStyle’,’-’) ;
hold on
chaine = get(handles.formule_intitule, ’string’) ;
if (nb_rect > 0 || nb_ell > 0)
chaine = strcat(chaine, ’+R’) ;
else
chaine = strcat(chaine, ’R’) ;
end
nb_rect = nb_rect + 1 ;
chaine = strcat(chaine, num2str(nb_rect)) ;
set(handles.formule_intitule, ’string’, chaine) ;
rect(nb_rect).xx = X ;
rect(nb_rect).yy = Y ;
rect(nb_rect).ll = L ;
rect(nb_rect).hh = H ;
strcat(’Affichage du rectangle [X, Y, L, H] = ’,...
num2str(X), ’, ’, num2str(Y), ’, ’, num2str(L), ’, ’, num2str(H))) ;
end
end
end
IV
Programme 11 Tracé d’une ellipse
function bouton_ellipse_Callback(hObject, eventdata, handles)
e = 1 ;
x1_rect = str2double(traitement(get(handles.x1_rect, ’String’))) ;
x2_rect = str2double(traitement(get(handles.x2_rect, ’String’))) ;
y1_rect = str2double(traitement(get(handles.y1_rect, ’String’))) ;
y2_rect = str2double(traitement(get(handles.y2_rect, ’String’))) ;
if isnan(x1_rect) | isnan(x2_rect) | isnan(y1_rect) | isnan(y2_rect)
[’erreur nř’num2str(nb_messages)’:coordonnees du rectangle invalides’]);
else
L = abs(x2_rect - x1_rect)/2 ; % cotes paralleles a l’axe des abscisses
H = abs(y2_rect - y1_rect)/2 ; % cotes paralleles a l’axe des ordonnees
X = min(x1_rect, x2_rect) ;
% [X,Y] sommet du triangle en bas a gauche
Y = min(y1_rect, y2_rect) ;
if L == 0 |H == 0
[’erreur nř’ num2str(nb_messages) ’ : L <= 0 ou H <= 0’]) ;
else
rectangle(’Position’,[X,Y,2*L,2*H], ’Curvature’,[1,1],...
’LineWidth’,e,’LineStyle’,’-’) ;
hold on
chaine = get(handles.formule_intitule, ’string’) ;
if (nb_rect > 0 || nb_ell > 0)
chaine = strcat(chaine, ’+E’) ;
else
chaine = strcat(chaine, ’E’) ;
end
nb_ell = nb_ell + 1 ;
chaine = strcat(chaine, num2str(nb_ell)) ;
set(handles.formule_intitule, ’string’, chaine) ;
ell(nb_ell).xx = X ;
ell(nb_ell).yy = Y ;
ell(nb_ell).ll = L ;
ell(nb_ell).hh = H ;
strcat(’Affichage de lellipse [X, Y, L, H] = ’,...
num2str(X), ’, ’, num2str(Y), ’, ’,...
num2str(L), ’, ’, num2str(H))) ;
end
end
end
V
Programme 12 Récupération de la chaı̂ne entrée par l’utilisateur
function bouton_formule_Callback(hObject, eventdata, handles)
e = 1 ;
chaine = traitement(get(handles.formule_intitule, ’String’)) ;
donnees = recolte_donnees(chaine) ; % vecteur (signe caractere numero)
if size(donnees,2) == 0
[’erreur nř’num2str(nb_messages)’:chaine pour le maillage invalide’]) ;
else
correct = 1 ;
% verifier que les numeros entres sont bons
i = 1 ;
while correct && i <= size(donnees,2)
correct = (donnees(i).caractere==’R’&& donnees(i).numero<= nb_rect)...
||(donnees(i).caractere==’E’&& donnees(i).numero<= nb_ell);
i = i + 1 ;
end
if correct
[Xmin,Xmax,Ymin,Ymax] = coordonnees(handles) ;
px = (Xmax - Xmin)/100 ;
py = (Ymax - Ymin)/100 ;
x = Xmin:px:Xmax ;
y = Ymin:py:Ymax ;
for i=1:100
for j=1:100
if appartient(x(i),y(j),donnees,rect,ell) > 0
rectangle(’Position’,[x(i)-px/4,y(j)-py/4,px/2,py/2],...
’Curvature’,[1,1], ’LineWidth’,1.5,’LineStyle’,’-’) ;
end
end
end
hold on
else
indices de rectangles ou dellipses invalides’]) ;
end
end
end
VI
Programme 14 Fonction d’appartenance à une surface
function booleen = appartient(x,y,donnees,v_rect,v_ell)
i = size(donnees,2) ;
booleen = 0 ;
% 0 -> On ne sait pas.
% -1 -> pas dedans
% 1 -> dedans
while ~booleen && i > 0
point = donnees(i) ;
num = point.numero ;
if (point.caractere == ’R’ && x >= v_rect(num).xx &&...
y >= v_rect(num).yy && ...
x <= (v_rect(num).xx + v_rect(num).ll) && ...
y <= (v_rect(num).yy + v_rect(num).hh)) || ...
(point.caractere == ’E’...
&& norm([((x - v_ell(num).xx)/v_ell(num).ll - 1)...
((y - v_ell(num).yy)/v_ell(num).hh - 1)]) <= 1)
if point.signe == ’+’
booleen = 1 ;
else
if point.signe == ’-’
booleen = -1 ;
end
end
end
i = i - 1 ;
end
VII
Programme 15 Fonction enregistrer
function bouton_enregistrer_Callback(hObject, eventdata, handles)
A=[0,0];
B=null(A);
chaine = traitement(get(handles.formule_intitule, ’String’)) ;
% donnees : vecteur de structure (signe caractere numero)
donnees = recolte_donnees(chaine) ;
if size(donnees,2) == 0
[’erreur nř’num2str(nb_messages)’:chaine pour le maillage invalide’]);
else
% verifier que les numeros entres sont bons !!!
correct = 1 ;
i = 1 ;
while correct && i <= size(donnees,2)
correct = (donnees(i).caractere == ’R’ && donnees(i).numero <= nb_rect)...
|| (donnees(i).caractere == ’E’ && donnees(i).numero <= nb_ell) ;
i = i + 1 ;
end
if correct
[Xmin,Xmax,Ymin,Ymax] = coordonnees(handles) ;
px = (Xmax - Xmin)/100 ;
py = (Ymax - Ymin)/100 ;
x = Xmin:px:Xmax ;
y = Ymin:py:Ymax ;
for i=1:100
for j=1:100
if appartient(x(i),y(j),donnees,rect,ell) > 0
B=[B;x(i),y(j)];
end
end
end
%save(’resultat.mat’,’B’);
[filename, pathname] = uiputfile(’*.mat’, ’Pick an M-file’) ;
if isequal(filename,0) || isequal(pathname,0)
disp(’User pressed cancel’)
else
save(fullfile(pathname, filename),’B’) ;
end
else
indices de rectangles ou dellipses invalides’]) ;
end
end
end
VIII
IX
X

Rapport

Transcription

Documents pareils

Graphical User Interface (GUI).... avec Matlab.

mud mud - Stone Tile

Planet Jogging

Liste des piêces pour GK1000 COUPE

betontech - Stone Tile

ENDURO KTM 530 EXC 2009, 220 heures

Fusion d`images satellites

white mat silver mat ivory mat white strut silver strut ivory

Formulaire au format PDF