Docstoc

Algorithme de calcul - Wikispaces

Document Sample
Algorithme de calcul - Wikispaces Powered By Docstoc
					                Projet Géomatique
     Cycle des Ingénieurs de l’ENSG (IT3)



Extraction automatique de crêtes et talwegs




        Ismaila GIROUX, Clotilde MOHSEN, Loïc TACHET

                        Février 2008




                                                       1
Tables des matières

Tables des matières .................................................................................................................... 2

Introduction ................................................................................................................................ 4

Description générale ................................................................................................................... 5

   I       Structure HBDS : ........................................................................................................... 5

   II      Architecture .................................................................................................................... 6

   III         Graphe d’enchaînement.............................................................................................. 8

Algorithme de calcul .................................................................................................................. 8

   I       Graphe d’appel ............................................................................................................. 13

   II      Algorithmes .................................................................................................................. 13

Optimiseur d’accès ................................................................................................................... 34

Couche graphique ..................................................................................................................... 35

   I       Tracé du MNT .............................................................................................................. 35

   II      Tracé du graphe ............................................................................................................ 37

   III         Anaglyphe ................................................................................................................ 39

   IV          Les fonctions clavier ................................................................................................ 40

   V       Les fonctions souris ...................................................................................................... 40

   VI          Les fonctions de calcul associés au graphisme ........................................................ 40

Interface Homme Machine ....................................................................................................... 41

   I       Aspect général de l’IHM .......................................... Error! Bookmark not defined.42

   II      Ouverture de fichier ................................................. Error! Bookmark not defined.42

   III         Mode d’affichage ................................................. Error! Bookmark not defined.42

   IV          Affichage des crêtes/talwegs ................................ Error! Bookmark not defined.42

   V       Transformations ....................................................... Error! Bookmark not defined.43

Conclusion ................................................................................................................................ 44

Glossaire et sigles utiles ........................................................................................................... 45


                                                                                                                                             2
Sources ..................................................................................................................................... 46

Annexes .................................................................................................................................... 47




                                                                                                                                              3
Introduction

Le projet avait comme but d’extraire des lignes de crêtes et de talwegs, ce qui constitue un
problème fondamental en Géomatique. A partir d’un simple fichier MNT pouvant avoir
divers formats en fonction de sa régularité ou non, et en utilisant un maillage, il fallait alors
tracer les graphes correspondants à ces lignes caractéristiques et les représenter.
Le travail se divisait ainsi en plusieurs parties, une phase d’algorithmique visant à détecter les
crêtes/talwegs et à construire les graphes correspondants, une phase de représentation
graphique à l’aide des librairies OpenGL, et enfin la mise en place d’une IHM permettant à
l’utilisateur de pouvoir charger plusieurs MNT différents et visualiser les résultats du calcul.




                                                                                                4
Description générale

  I       Structure HBDS :




                               Figure 1 : Structure HBDS du projet

Le but du projet est d’obtenir deux graphes distincts pour les crêtes et les talwegs, à partir
d’un semis de points connus en X, Y, Z. Ce semis de points est automatiquement associé à un



                                                                                            5
maillage, c’est le cas si le MNT est régulier, sinon il faut appliquer un algorithme
d’interpolation pour construire un maillage régulier.

  II      Architecture

Le projet peut se décomposer en plusieurs couches. Cet agencement simplifie l’approche du
problème. De plus, il permet l’indépendance des différentes abstractions concentriques, ainsi
une modification dans une couche donnée ne bouleversera pas les couches supérieures.

En amont, un fichier de MNT et/ou un graphe de crêtes et talwegs sont donnés pour le calcul.
On a également la possibilité d’exporter un graphe de crêtes et talwegs de la couche calcul
vers le noyau. Ensuite, le graphe des crêtes et talwegs est calculé, puis dessiné dans des
couches différentes qui communiquent avec l’Interface Homme Machine.




                                                                                           6
                                         CALCUL                                          DESSIN                  IHM
                  Charger MNT


MNT                                             G3D
                                                              Z                            ZDessin




                                  gs )
                                 lwe
                     e
                  ph

                             t ta
               gra


                            se
              r
          rte


                          rête
         po


                     e (c
        Ex


                    aph
                r gr




                                                              CR&TW
              orte
         Imp




                                         Graphe CR&TW                                     Graphe Dessin
SIF                               SIF    SXYZ         PAXYZ   AXYZ                 SIF   SXYZ     PAXYZ   AXYZ


SXYZ


PAXYZ


AXYZ




                                                  Figure 2 : architecture du programme


                                                                                                                       7
Algorithme de calcul

  I       Graphe d’enchaînement




                                Figure 3 : Graphe d’enchaînement

La première partie du calcul consiste au traitement du MNT, à savoir s’il est régulier ou
irrégulier. Deux premiers algorithmes consistent à créer un maillage régulier de valeurs en Z à
partir d’un MNT irrégulier, ils ne sont donc pas nécessaires pour un MNT régulier, à moins de
fabriquer un maillage différent de celui du MNT d’origine.




                                                                                             8
A partir d’un semis de point, il faut donc rattacher chaque point à une maille donnée
(Algorithme Rattach_point), pour pouvoir ensuite interpoler et calculer la valeur en Z de
chaque nœud du maillage (Algorithme G3D) à l’aide de la méthode du Paraboloïde
hyperbolique de Laporte. Pour interpoler, un minimum de 6 points est nécessaire, ainsi, s’il
n’y a pas assez de points dans la maille, il est possible d’effectuer jusqu’à 3 agrandissements
de la fenêtre de calcul.

TXYZ
      1    10   460   412                                                   MNT
      2    20   190   430
      3    20   410   100                500

      4    90    50   448
      5   110   260   131
      6   130   420   423                400

      7   150   140   277
      8   180   460   149
      9   190   180   244                300

     10   260    90   378
     11   290   310   343
     12   320   210    17                200

     13   360   450   400
     14   370   230   244
     15   490   350   250 NTXYZ=15       100




                                          0
                                               0          100         200          300     400   500


PT
      1    1
      2    3                         C
      3    6                                          2       2   0         1     0 NX=5
      4    8                                          0       0   1         0     1
      5   13                                          0       1   0         2     0
      6   11                                          1       2   0         0     0
      7   15                                          1       0   1         0     0
      8    5                                       NY=5
      9   12                                              +
     10   14                         PT
     11    2                                          1       1   1         1     1 NX=5
     12    7                                          1       1   1         1     1
     13    9                                          1       1   1         1     1
     14    4                                          1       1   1         1     1
     15   10 NTXYZ=15                                 1       1   1         1     1
                                                   NY=5

                                 Figure 4 : Principe de rattach_point




                                                                                                       9
                                                             INTERXY

                       Figure 5 : Recherche des points et interpolation avec INTERXY

Une fois que l’on a obtenu un maillage bien régulier (X0, Y0, DX, DY, NX, NY) en Z, on
peut lancer la détection de crêtes/talwegs, la deuxième étape consiste donc à balayer cette
matrice de Z à la fois horizontalement et verticalement de manière à repérer les creux (pour
les talwegs) lorsque Zi-1,j ≥ Zi,j ≤ Zi+1,j et les bosses (pour les crêtes) lorsque Zi-1,j ≤ Zi,j ≥ Zi+1,j.

Pour éviter d’avoir des crêtes/talwegs trop larges, on se fixe un critère d’arrêt lors du
balayage : si l’on rencontre plus 5 « vrais » à la suite, on remet tout à « faux ». Physiquement
ce cas correspondrait à une large vallée (talwegs) ou à un plateau (crêtes). Une fois les 2
matrices de balayage, H et V, remplies, on fait l’union entre les deux pour obtenir une matrice
nommée MT (talwegs) ou MC (crêtes).




                                                                                                        10
  MNT

  NY                                                             H


             390   227        454         180   228                             0       1       0   1   0

             235   231        345         388   451                             0       1       0   0   0

             211       51     485         304    99                             0       1       0   0   0

             276       47     458         267   117                             0       1       0   0   0

             425   198        18          166   191                             0       0       1   0   0
  Xo, Yo                                                NX


  V                                                              T=HUV


               0        0         0        0        0                           0       1       0   1   0

               0        0         1        0        0                           0       1       1   0   0

               1        0         0        0        0                           1       1       0   0   0

               0        1         0        0        0                           0       1       0   0   0

               0        0         0        0        0                           0       0       1   0   0




                                      Figure 6 : Balayage de la matrice des Z

La 2ème étape est une cure d’amaigrissement de la matrice de crêtes/talwegs obtenue
précédemment. Le principe est d’éliminer tout « paquet rectangulaire de vrais » ayant pour
taille minimale 2*2 pour pouvoir former par la suite un graphe. Pour pouvoir amaigrir, on
récupère le barycentre de la fenêtre scannée (en orange sur la figure ci-dessous) et on repère
les extrémités autour (en violet). On forme ensuite des arcs amaigris entre chaque extrémité et
le barycentre et on répète l’opération jusqu’à ce que tous les paquets aient été supprimés.


    T                  JMIN       NCF                                BR
                   1                                                                3       2
                   1                                    1                           4       6
                   1    1                   1   1                                   8       2
    IMIN                1     1       1     1                                       8       6

                        1     1       1     1               IBAR, JBAR
                        1     1       1     1
    NLF                 1     1       1

                   1    1                   1
                   1                            1       1
              1    1
              1
    Xo, Yo                                                  NX
                                                                                                            11
                                 T                           JMIN           NCF
                                                         1                                                                  3        2
                                                         1                                     1                            3        6
                                                         1    1                   1    1                                    8        2
                                 IMIN                         1              1    1                                         8        6

                                                                        1                          IBAR, JBAR
                                                              1              1
                                 NLF                          1              1

                                                         1    1                   1
                                                         1                             1       1
                                                 1       1
                                                 1
                                 Xo, Yo                                                            NX



          Figure 7 : Principe de la cure d’amaigrissement (récupération du barycentre et des branches)

L’étape suivante est la recherche des voisins : pour chaque « vrai », on remplit la matrice P
qui donne la ligne sur la table PVOIS, puis la tables de pointeurs de voisin (PVOIS) et la table
listant tous les voisins (VOIS).

      T                                                                      PVOIS                      VOIS
                 0   1   0   0       0   0   0       0   1    1     1             1    1   1              1    2     2

                 0   1   0   0       0   0   0       1   0    0     0             2    2   3              2    1 10
                 0   1   0   0       0   1   1       0   0    0     0             3    4   5              3    2     8

                 0   0   1   0       1   0   0       0   0    0     0             4    6   6              4    1     9
                 0   0   0   1       0   0   0       0   0    0     0             5    7   8              5    1 11
                 0   0   0   1       0   0   0       0   0    0     0             6    9 10               6    1 10

                 0   0   1   0       1   0   0       0   0    0     0             7    11 12              7    1     2
                 0   1   0   0       0   1   0       0   0    0     0             8    13 14              8    3     2

                 0   1   0   0       0   0   1       0   0    0     0             9    15 16              9    1     9
                 1   0   0   0       0   0   0       1   1    0     0             10   17 18             10    3     7
                 1   0   0   0       0   0   0       0   0    1     1             11   19 20             11    2     2
                                                                                  12   21 23             12    4     3
      P                                                                           13   24 26             13    3     7
                 0   1   0   0       0   0   0       0   2    3     4             14   27 28             14    4     5

                 0   5   0   0       0   0   0       6   0    0     0             15   29 30             15    3     6
                 0   7   0   0       0   8   9       0   0    0     0             16   31 32             16    2     8
                 0   0 10    0 11        0   0       0   0    0     0             17   33 34             17    3     2
                 0   0   0 12        0   0   0       0   0    0     0             18   35 36             18    5     4

                 0   0   0 13        0   0   0       0   0    0     0             19   37 38             19    3     6
                 0   0 14    0 15        0   0       0   0    0     0             20   39 40             20    5     4

                 0 16    0   0       0 17    0       0   0    0     0             21   41 42             21    6     4 coordonnées
                 0 18    0   0       0   0 19        0   0    0     0             22   43 44             22    4     3 des voisins
                                                                                                                          de 12
                20   0   0   0       0   0   0 21 22          0     0             23   45 45             23    4     5
                23   0   0   0       0   0   0       0   0 24 25                  24   46 47             24    5     4
                                                                                  25   48 48             25    7     3
                                                                                                         26    7     5

                                                                                                         27

                                                                                                         28
                                                                                                               etc


                                         Figure 8 : Balayage de la matrice des Z

Enfin une fois tous les voisin connus, il nous est possible de tracer les arcs. Ainsi, on
recherche les points ayant un nombre de voisins différent de 2, ce qui permet de dire que c’est


                                                                                                                                         12
un sommet et pour chacun de ces points, on parcourt tous les arcs qui le concernent en
remplissant au fur et à mesure, toutes les tables caractéristiques des graphes. Il s’agit en sortie
des tables, SXYZ, SIF, AXYZ, PAXYZ et cela à la fois pour le graphe des crêtes et à la fois
pour les graphes de talwegs.




   II     Graphe d’appel

Ce graphe d’appel ne prend en compte que les algorithmes de calcul, les procédures
d’affichage ou d’IHM ne sont pas traités dans cette partie.




                        Figure 9 : Graphe d’appel pour les algorithmes de calcul

   III    Algorithmes




                                                                                                13
                                             RATTACH_POINT
variable      mode            genre      type                                 description
                                                  Paramètres formels
 TXYZ            IN           matrice     réel        X, Y, Z de tous les points de notre semi de point de départ
                            (NTXYZ*3)
NTXYZ          IN             scalaire   entier                        Nombre de points de départ
X0, Y0         IN             scalaire    réel                   Coordonnées de l’origine du maillage
DX, DY         IN             scalaire    réel                               Pas du maillage
NX, NY         IN             scalaire   entier                      Nombre de nœuds du maillage
  C           OUT             matrice    entier   matrice de compteur, nombre de points du jeu de données dans chaque
                             (NY*NX)                                              maille
   P          OUT             matrice    entier   matrice de pointeurs, adresse dans la table PT pour récupérer tous les
                             (NY*NX)                                points se situant dans une maille
   PT         OUT             vecteur    entier             ensemble des points triés dans l’ordre du maillage
                             (NTXYZ)
                                                    Variables locales
        IM, JM               scalaire    entier              Position (ligne, colonne) du nœud de la maille
        BI, BF               scalaire    entier        Bornes de balayage de la table PT pour le nœud (IM, JM)

Principe :

A partir du semi de point de départ connu en X,Y,Z (table TXYZ), on trace un maillage
(X0,Y0,DX,DY,NX,NY) et on cherche à rattacher chaque point à une maille donnée. On
fabrique ainsi deux matrices correspondant au maillage à savoir le compteur C (nombre de
points dans chaque maille) et le pointeur P (adresse du 1er point pour chaque maille dans PT),
PT étant le vecteur correspondant au semi de point trié avec le maillage.


RATTACH_POINT (TXYZ, NTXYZ, X0, Y0, DX, DY, NX, NY, C,

P, PT) :

Initialisation des matrices compteur et pointeur


                              Ci,j  0 ; Pi,j  0 ;
         NY            NX
i : 1        j : 1                                   j
                                                           i ;

          NTXYZ
 k : 1               Récupération pour chaque point de la ligne et colonne de la maille



JM  (TXYZk,1 – X0 + DX – 1)  DX ; IM                           (TXYZk,2 – Y0 + DY – 1)  DY ;


On incrémente le compteur de la maille CIM,JM  CIM,JM + 1 ;                 k

                                                                                                              14
                 i = 1 1ère maille --> pointeur à 1 Pi,1  1  on est sur la 1ère colonne, on
          NY
 i : 1
additionne donc compteur et pointeur de la dernière colonne à la ligne précédente


Pi,1    Pi-1,NX + Ci-1,NX       Pour tous les autres cas, on additionne compteur et pointeur de la

                                       Pi,j  Pi,j-1 + Ci,j-1;
                                  NX
colonne précédente       j : 2                                  j i

         NTXYZ
k : 1               remplissage de la table PT avec chaque point de TXYZ


On récupère à nouveau la maille où se trouve le point


JM  (TXYZk,1 – X0 + DX – 1)  DX ; IM  (TXYZk,2 – Y0 + DY – 1)  DY ;


BI      PIM,JM; BF  PIM,JM + CIM,JM – 1 ;          On stocke dès que l'on rencontre un 0


                      0   PTh  k ;2    
          BF
h : BI        PTh
                                             h k




                                                                                                 15
                                                  G3D

variable       mode         genre        type                            description
                                          Paramètres formels
        TXYZ, NTXYZ, X0, Y0, DX, DY, NX, NY, C, P, PT (mode IN) : voir procédure RATTACH_POINT
 FICH      INOUT     Scalaire  Caractères    Fichier pour archiver les problèmes rencontrés (lorsqu’il n’y a pas
                                 (100)                assez de points du MNT à proximité d’un nœud)
 MATZ        OUT     matrice      réels                Matrice régulière donnant les Z sur le maillage
                    (NY*NX)
                                           Variables locales
   IMIN, JMIN,       scalaire    entier             coordonnées min et max de la fenêtre d’interpolation
  IMAX, JMAX
      BI, BF         scalaire    entier           Bornes de balayage de la table PT pour un nœud donné
     LPMNT           Vecteur     entier               Liste des points du MNT compris dans la maille
                    (NPMNT)
     NPMNT           scalaire    entier              Nombre de points du MNT dans une maille donnée
        Z            scalaire      réel        Valeur en Z, calculée par INTERXY, pour un nœud du MNT
                                                Appels
                 INTERXY                       Méthode du Paraboloïde hyperbolique de Laporte, renvoie une
                                             valeur de Z pour un point (X, Y) à partir d’un échantillon de point
                  ECRIRE                     Répertorie les problèmes causés lors de la recherche de points pour
                                                                         INTERXY

Principe :

On parcourt le maillage, pour chaque maille, on répertorie les points du MNT qu’elle contient.
On délimite une fenêtre puis on regarde s’il y a au moins 6 points à l’intérieur sinon on
agrandit le dispositif sauf si la fenêtre est de 7 sur 7 auquel cas, on se limite aux points
présents. Dès que l’on a trouvé les 6 points nécessaires, on interpole avec la méthode du
Paraboloïde hyperbolique (procédure INTERXY). Pour chaque nœud de maille, on calcule
ainsi un Z associé et on sort à la fin une matrice Z du maillage régulier.

G3D (TXYZ, NTXYZ,                  X0, Y0, DX, DY, NX, NY, C, P, PT,
FICH, MATZ) :             
         NY            NX
I : 1         J: 1        si la maille ne contient aucun point, on passe au suivant



Ci,j = 0   NPMNT  0; BI  Pi,j; BF  PI,J + CI,J – 1;


          BF
k : BI        On récupère tous les points du MNT contenus dans cette maille



NPMNT  NPMNT + 1; LPMNTNPMNT  PTk; 
                                                           k



 LPMNT contient les point du MNT dans la maille (I, J)

                                                                                                     16
             NP  0; on délimite une fenêtre d’interpolation avec la prise en compte de l’effet de
         3
L : 0
bord si besoin


             IMIN  I – L; IMIN<1 IMIN  1  ;


             IMAX  I + L; IMAX>NY IMAX  NY  ;


             JMIN  J – L; JMIN<1 JMIN  1  ;


             JMAX  J + L; JMAX>NX JMAX  NX  ;


                                             CM,N = 0   La maille contient des points du MNT
               IMAX                   JMAX
M : IMIN                 N : JMIN

             BI  PM,N ; BF  PM,N + CM,N – 1;


                  q  PTp; NP  NP + 1; Récupération des coordonnées des points de la maille
             BF
 p : BI
TXNP  TXYZq,1; TYNP  TXYZq,2; TZNP  TXYZq,3 ;                       N M ;
                                                                    p



NP  6 au moins 6 points  on peut interpoler


                   p  LPMNTk ; X  TXYZp,1 ; Y  TXYZp,2 ;
         NPMNT
k : 1

récupération du Z du nœud de la maille grâce à INTERXY


INTERXY(TX,                 TY, TZ, X, Y, Z) ;             MATZI,J  Z ; constitution de la

matrice de Z 
                      k




                                                                                               17
2    on passe à la maille suivante     pas assez de points, on essaie d'agrandir la fenêtre
L = 3  C'est fichu pour tous les points de la maille


                      LPMNTk ; ECRIRE(FICH, p) ; k
         NPMNT
k : 1           p                                              on passe à la maille suivante


comme si de rien n'était   2  l J I 




                                                                                           18
                                                           BALAYAGE
variable        mode            genre            type                                 description
                                                            Paramètres formels
    Z            IN            matrice           réel               Z du maillage obtenu par l’interpolation du MNT
                              (NY*NX)
  TYP            IN            scalaire        caractère         « T » pour balayer les talwegs, « C » pour balayer les crêtes
                                                  (1)
NX, NY           IN            scalaire         entier                         Nombre de nœuds du maillage
  T             OUT            matrice         booléen            Matrice des crêtes/talwegs (non amaigrie) après balayage
                              (NY*NX)
                                                             Variables locales
         H, V                  matrice         booléen                    Scan horizontal/vertical de la matrice Z
                              (NY*NX)
         CP                    scalaire         entier                          Compteur de  consécutifs

Principe :

On initialise deux matrices H et V de même taille que la matrice Z, puis on scanne la matrice
Z horizontalement et verticalement. Avec un compteur, on vérifie que le nombre de 
n’excède pas 5 auquel cas, on les supprime pour ne pas avoir de crêtes/talwegs trop larges.
Une fois les 2 matrices obtenues, la réunion des 2 nous donne la matrice des crêtes/talwegs.

BALAYAGE (Z, TYPE, NX, NY, T) :                                        Initialisation des matrices H et V



                                       ; Vi,j   ; j i ;
         NY              NX
i : 1          j : 1        Hi,j


On balaye horizontalement


CP  0 ;                                       TYPE = T 
                         NY             NX-1
                i : 1         j : 2

Test pour les talwegs B                  (Zi,j-1  Zi,j     Zi,j+1  Zi,j) 

Test pour les crêtes B                 (Zi,j-1  Zi,j      Zi,j+1    Zi,j )  ;


B  On est dans une crête/ talweg Hi,j                        ; CP  CP + 1 ;                 Hi,j      ; CP > 5
                                                                                           k : 1                      
                                                                                                          CP
    C'est trop large, ce n'est pas une crête/talweg, on remet tout à                                            Hi,j-k


 ; k              et on réinitialise le compteur CP              0  j i ;


                                                                                                                         19
On balaye verticalement


CP  0 ;                                      TYPE = T 
                        NX             NY-1
               j : 1         i : 2

Test pour les talwegs B               (Zi-1,j  Zi,j  Zi+1,j    Zi,j ) 


Test pour les crêtes B               (Zi-1,j    Zi,j    Zi+1,j    Zi,j ) 


B  On est dans une crête/talweg Vi,j                      ; CP  CP + 1 ;     Vi,j         ; CP > 5 
C'est trop large, ce n'est pas une crête/talweg, on remet tout à                                        ;
                                                                                          CP
                                                                                 k : 1        Vi-k,j


k          et on réinitialise le compteur CP             0  j i ;

Union des deux matrices pour former la matrice des crêtes/talwegs T


                                      Hi,j  Vi,j j i ; 
         NX             NY
i : 1         j : 1        Ti,j




                                                                                                          20
                                                 CURE

variable        mode       genre       type                                 description
                                                Paramètres formels
   T            INOUT     matrice     booléen                  Matrice des crêtes/talwegs à amaigrir
                         (NY*NX)
NX, NY           IN       scalaire     entier                          Nombre de nœuds du maillage
                                                Variables locales
        S                 scalaire     entier                       compteur d’éléments dans la fenêtre
     SMAX                 scalaire     entier                    Nombre total d’éléments dans la fenêtre
      MAX                 scalaire     entier               Nombre d’éléments maximum pour une fenêtre
     NL, NC               scalaire     entier             Nombre de lignes/colonnes provisoires de la fenêtre
   IMIN, JMIN             scalaire     entier                         Point haut gauche de la fenêtre
    NLF, NCF              scalaire     entier           Nombre de lignes/colonnes finaux de la fenêtre à traiter
   IBAR, JBAR             scalaire     entier                       Position du barycentre de la fenêtre
       CP                 scalaire     entier            Compteur de  sur une branche au bord de la fenêtre
       NB                 scalaire     entier             Nombre de branches trouvées au bord de la fenêtre
       BR                 Matrice      entier    Récupération de la position du point central de la branche en i et j au
                          (NB*2)                                             bord de la fenêtre
     LI, CI               scalaire     entier                i et j de la branche récupérée dans la table BR
   NLB, NCB               scalaire     entier   Différence en i et en j entre le point de la branche au bord de la fenêtre
                                                                              et le barycentre.
           F              scalaire      réel    Facteur représentant le rapport entre NLB et NCB ou l’inverse de telle
                                                                    manière à ce qu’il soit supérieur à 1
           F2             scalaire     entier    entière de 1/F * j, facteur permettant de savoir où placer les  pour
                                                                      constituer une branche amaigrie
                                                      Appels
                        ENT                                              Récupère la partie entière
                        ABS                                                    Valeur absolue

Principe :


On cherche le un « paquet » rectangulaire constitué entièrement de  pour l’amaigrir, une
fois le paquet repéré avec sa position (IMIN, JMIN) et sa taille (NCF,NLF), on cherche le
point le plus proche du barycentre (IBAR,JBAR). On recherche maintenant les  sur les 4
côtés de notre fenêtre de manière à repérer les branches, on remplit au fur et à mesure la
matrice bicolonne BR avec pour chaque ligne une branche matérialisée par la position (i,j) du
point central de cette branche sur le côté de la fenêtre. Une fois les 4 côtés scannés, on a NB
branches. On remplace maintenant les  de la fenêtre par des  (sauf le barycentre) et on
doit compléter avec les branches. Pour les NB branches, on calcule NLB et NCB représentant
la différence entre le barycentre (IBAR,JBAR) et l’extrémité de la branche (BR 1, BR2), si
NLB=0, la branche est verticale, si NCB=0, la branche est horizontale, dans le cas contraire,
on calcul un facteur de 0 ou 1 pour placer approximativement les .

CURE (T, NX, NY) :                         MAX représente la plus grande fenêtre, elle a NL


lignes et NC colonnes MAX             1 ; NL  2 ; NC  2 ; On parcours toute la matrice T
sauf la dernière ligne et la dernière colonne pour rechercher une fenêtre remplie de



                                                                                                             21
                                NL  2 ; NC  2 ;   Ti,j     ;       On a un  , on regarde les
         NY-1            NX-1
i : 1          j : 1
voisins


       S0;                            i+L-1 > NY       j+C-1 > NX        Ti+l-1,j+c-1  S   S+1
                           NL        NC
                  l : 1 c : 1

    cl ; SMAX  1 ; S                   NL * NC    2   La fenêtre est remplie de 

            S ; B   ; c : 1
                                          NC
SMAX                                           On scanne la ligne suivante si on n’est pas au bord



i + NL – 1       NY  Ti+NL,j+c-1           On rencontre un       B         c ;

B         Pas de , on agrandit la fenêtre d’une ligne si on n’est pas au bord i+NL < NY




      NL + 1 ;                            ; l : 1
                                                             NL
NL                                        B                       On scanne la colonne suivante si on


n’est pas au bord j + NC – 1           NX  Ti+l-1,j+NC        On rencontre un          B    

    l ; B  Pas de , on agrandit la fenêtre d’une colonne si on n’est pas au
bord


j + NC < NX  NC             NC + 1 ;      On a délimité une fenêtre   ;

Il faut maintenant amaigrie la fenêtre calculée IMIN  i ; JMIN             j ; NCF  NC ;

NLF  NL ; SMAX > MAX  On récupère la taille de la fenêtre max de T


MAX        SMAX  



                                                                                                     22
Récupération du barycentre de la fenêtre IBAR         IMIN + NLF  2 ; JBAR  JMIN +
NCF  2 ;


Récupération des branches dans les 4 directions NB      0;

BR: matrice bicolonne avec la position (ligne et colonne) d'une branche


JMIN  1  On est au bord gauche  pas de branche à gauche 


                                                                CP  0 ; Tk,JMIN-1
                                                   IMIN+NLF+1
Récupération des branches à gauche   k : IMIN-1

CP  CP + 1 ; k = IMIN+NLF+1  Si on a un 1 en dernier, il faut aussi le prendre comme

branche NB      NB + 1 ; BRNB,1  k – CP2 ; BRNB,2  JMIN-1 ;  

    CP    0  On traite cette branche NB  NB + 1 ; BRNB,1  (k-1) – CP2 ;

BRNB,2     JMIN-1 ; CP  0 ;    k ; 

JMIN + NCF = NX  On est au bord droit  pas de branches à droite           

                                                                CP  0 ; Tk,JMIN+NCF+1
                                                   IMIN+NLF+1
Récupération des branches à droite   k : IMIN-1

CP  CP + 1 ; k = IMIN+NLF+1  Si on a un 1 en dernier, il faut aussi le prendre comme

branche NB      NB + 1 ; BRNB,1  k – CP2 ; BRNB,2  JMIN+NCF+1 ;   

CP    0  On traite cette branche NB  NB + 1 ; BRNB,1  (k-1) – CP2 ;

BRNB,2     JMIN+NCF+1 ; CP  0 ;    i ; 


                                                                                          23
                                                                  CP  0 ; TIMIN-1,k
                                                     JMIN+NCF+1
Récupération des branches en haut      k : JMIN-1

CP  CP + 1 ; k = JMIN+NCF+1  Si on a un 1 en dernier, il faut aussi le prendre comme

branche NB          NB + 1 ; BRNB,1  IMIN-1 ; BRNB,2  k - CP2 ;  

   CP     0  On traite cette branche NB  NB + 1 ; BRNB,1  IMIN-1 ;

BRNB,2     (k-1) - CP  2 ; CP  0 ;    k ;

IMIN + NLF = NY  On est au bord bas  pas de branches en bas 


                                                                  CP  0 ; TIMIN+ NLF+1,k
                                                    JMIN+NCF+1
Récupération des branches en bas      k : JMIN-1

CP  CP + 1 ; k = JMIN+NCF+1  Si on a un 1 en dernier, il faut aussi le prendre comme

branche NB          NB + 1 ; BRNB,1  IMIN+NLF+1 ; BRNB,2  k - CP2 ;  

   CP     0  On traite cette branche NB  NB + 1 ; BRNB,1  IMIN+NLF+1 ;

BRNB,2     (k-1) - CP  2 ; CP  0 ;    k ; 

                                    l : IMIN                                                 ; c
                                                     IMIN+NL               JMIN+NCF
On remplit la fenêtre avec des                                 c : JMIN              Tl,c


l ; TIBAR,JBAR   ; On amaigrit pour chaque branche

                    BRk,1 ; CI  BRk,2 ; NCB  ABS(CI – JBAR) ;
         NB
k : 1        LI



NLB  ABS(LI – IBAR) ;




                                                                                                   24
NCB = 0  On trace une ligne verticale                          TIBAR+m,JBAR  ;          
                                                          NLB
                                                 l : 1                                m



NLB = 0  On trace une ligne horizontale                          TIBAR,JBAR+m  ;             
                                                            NCB

                                                      m:1                                    m



F: Coefficient entre 1 et n NCB  NLB  F  NCB/NLB ;


                    
                                                                     NCB
CI  IBAR               La branche va dans le bon sens      m : 1         calcul de la « pente » de notre


branche LI  IBAR  F2  ENT(1/F*m)                   F2  - ENT(1/F*m)             ;


TIBAR+F2,JBAR+m  ;                La branche va à rebrousse poil
                                m



                    calcul de la « pente » de notre branche LI  IBAR  F2  ENT(1/F*m)                  
          -NCB,-1
m : -1

F2    - ENT(1/F*m) TIBAR+F2,JBAR+m   ; m  On passe à la branche suivante 

     NLB/NCB ;                          
                                                                                           NLB
F                          LI  IBAR         La branche va dans le bon sens       m : 1         calcul de la


« pente » de notre branche CI  JBAR  F2                  ENT(1/F*m)  F2  - ENT(1/F*m) 
; TIBAR+m,JBAR+F2  ;                La branche va à rebrousse poil
                                  m



                    calcul de la « pente » de notre branche CI  JBAR  F2  ENT(1/F*m)                  
          -NLB,-1
m : -1

F2       - ENT(1/F*m) TIBAR+m,JBAR+F2   ; m  On passe à la branche suivante  k
La fenêtre a été amaigrie, on en cherche une nouvelle              j i

MAX = 1  Plus de fenêtre à amaigrir, la cure est terminée                   


                                                                                                          25
                                               RATTACH_VOIS
variable      mode           genre          type                               description
                                                   Paramètres formels
   T           IN          matrice         booléen               Matrice des crêtes/talwegs « amaigrie »
                          (NY*NX)
NX, NY         IN          scalaire         entier                            Nombre de nœuds du maillage
  P           OUT          matrice          entier         Matrice donnant la ligne dans la table PVOIS pour chaque élément
                          (NY*NX)                                                             de T
   B          OUT          matrice         booléen                 initialisé ici et utilisé dans la procédure GRAPHE
                          (NY*NX)
 PVOIS        OUT          matrice          entier                      Table des pointeurs sur la table des voisins
                        (NPVOIS*2)
NPVOIS        OUT          scalaire         entier              Cardinalité de PVOIS  nombre de  dans la matrice T
 VOIS         OUT          matrice          entier                       Table avec la position des voisins en i,j
                         (NVOIS*2)
NVOIS         OUT          scalaire         entier                  Cardinalité de VOIS  nombre total de voisins
                                                         Variables locales
        C                   scalaire        entier                                Compteur de voisins
BIL, BFI, BIC, BFC          scalaire        entier        Bornes de la fenêtre de recherche des voisins, par défaut -1 et 1 sauf
                                                                                      sur les bords

Principe :


Pour chaque   que l’on trouve dans la matrice T « amaigrie » en position Ti,j , on regarde
les 8 éléments adjacents et on récupère tous les voisins potentiels, c’est-à-dire les autres  ,
on fait correspondre à Pi,j la ligne dans la table de pointeurs PVOIS, cette table nous permet
pour chaque Ti,j de déterminer les lignes de début et de fin correspondantes aux voisins
potentiels de ce Ti,j dans la table VOIS. Attention, on ne peut rencontrer deux voisins côte à
côte d’où la nécessité d’un contrôle : si l’on est sur un voisin en diagonale, on ne le prend en
compte que s’il n’y a pas de  à côté. Ces tables pourront ensuite servir à la détermination
des sommets, points annexes…

RATTACH_VOIS (T, NX, NY,                                    P, B,        PVOIS, NPVOIS, VOIS,

NVOIS) :      

                                                                               ;  j i ;
                                     NY            NX
Initialisation de P         i : 1        j : 1        Pi,j       0 ; Bi,j



NPVOIS  0 ; NVOIS              0;

On parcourt T à la recherche des



                            Ti,j     NPVOIS  NPVOIS + 1 ;C  0 ;
         NY            NX
i : 1        j : 1

                                                                                                                       26
Gestion des effets de bord : on délimite la fenêtre de recherche


i = 1 BIL  0  BIL  -1  ;


i = NY BFL  0  BFL  1  ;


j = 1 BIC  0  BIC  -1  ;


j = NX BFC  0  BFC  1  ;


                                                             Ti+l, j+c  C  C + 1  
                                      BFL              BFC
Récupération des voisins      l : BIL      c : BIC                                     c l ;

C = 1  Pas de voisin, c’est un sommet isolé pas besoin de remplir les tables


Pi,j    -1 ;   Pi,j = -1 pour pouvoir repérer facilement les sommets isolés     

sinon Pi,j = ligne dans la table de pointeurs Pi,j      NPVOIS ;

Pointeur de début = nombre actuel de voisins PVOISNPVOIS,1              NVOIS+1 ;

Remplissage de la table VOIS

Élément en haut


i    1  Ti-1,j     C'est un voisin NVOIS    NVOIS + 1 ; VOISNVOIS,1  i-1 ;

VOISNVOIS,2      j  

Élément en bas




                                                                                                   27
i        NY      Ti+1,j      C'est un voisin NVOIS    NVOIS    + 1 ; VOISNVOIS,1    i+1 ;
VOISNVOIS,2     j  

Élément à gauche


j    1  Ti,j-1      C'est un voisin NVOIS    NVOIS + 1 ; VOISNVOIS,1  i ;

VOISNVOIS,2      j-1    

Élément à droite


j       NX  Ti,j+1  C'est un voisin NVOIS      NVOIS + 1 ; VOISNVOIS,1  i ;

VOISNVOIS,2      j+1    

Eléments de la diagonale  test en plus pour savoir s'il faut les compter ou non

Elément en haut à gauche


i    1  j  1 Ti-1,j-1  Ti-1,j  Ti,j-1          C'est un voisin NVOIS    NVOIS + 1 ;
VOISNVOIS,1      i - 1 ; VOISNVOIS,2  j - 1    

Elément en haut à droite


i  1  j  NX  Ti-1,j+1        Ti-1,j  Ti,j+1  C'est un voisin NVOIS  NVOIS + 1 ;

VOISNVOIS,1      i - 1 ; VOISNVOIS,2  j + 1    

Elément en bas à gauche


i  NY  j  1  Ti+1,j-1  Ti+1,j       Ti,j-1  C'est un voisin NVOIS  NVOIS + 1;



                                                                                            28
VOISNVOIS,1    i + 1 ; VOISNVOIS,2  j - 1    

Elément en bas à droite


i  NY  j  NX Ti+1,j+1  Ti+1,j    Ti,j+1  C'est un voisin NVOIS  NVOIS + 1;

VOISNVOIS,1    i + 1 ; VOISNVOIS,2  j + 1    

Pointeur de fin = nouveau nombre de voisins PVOISNPVOIS,2    NVOIS ;

 j i 




                                                                                  29
                                               GRAPHE
variable     mode        genre          type                                   description
                                             Paramètres formels
               T, P, VOIS, NVOIS, PVOIS, NPVOIS (mode IN) : voir procédure RATTACH_VOIS
                            X0, Y0, DX, DY, NX, NY (mode IN) : données du maillage
   B       INOUT       matrice       booléen     Matrice permettant d’éviter les doublons dans la constitution des
                      (NY*NX)                  tables SIF, repère le dernier élément d’un arc pour indiquer qu’on l’a
                                                                               déjà traité.
  NA         OUT       scalaire       entier                       Nombre d’arcs de notre graphe
  NS         OUT       scalaire       entier                    Nombre de sommets de notre graphe
NAXYZ        OUT       scalaire       entier                 Nombre de points annexes de notre graphe
 SXYZ        OUT       matrice         réel                      Coordonnées X, Y, Z des sommets
                       (NS*3)
  SIF        OUT       matrice        entier                   Sommets initial et final de chaque arc
                       (NA*2)
 AXYZ        OUT       matrice         réel                   Coordonnées X, Y, Z des points annexes
                     (NAXYZ*3)
PAXYZ        OUT       matrice        entier       Pointeurs initial et final de chaque arc dans la table des points
                       (NA*2)                                               annexes AXYZ
                                              Variables locales
       NPA             scalaire       entier           Nombre de points annexes sur l’arc que l’on parcourt
        NP             scalaire       entier         Nombre de nœuds de la maille sur l’arc que l’on parcourt
      PD, PF           scalaire       entier                   Pointeurs de début et de fin dans VOIS
       NV              scalaire       entier                               Nombre de voisins
   IOLD, JOLD          scalaire       entier                    Ligne et colonne du point précédent
 PDOLD, PFOLD,         scalaire       entier    Pointeurs de début et de fin dans VOIS et nombre de voisins pour le
     NVOLD                                                                  point précédent
      IC, JC           scalaire       entier                      Ligne et colonne du point courant
 PDC, PFC, NVC         scalaire       entier    Pointeurs de début et de fin dans VOIS et nombre de voisins pour le
                                                                              point courant
  INEW, JNEW           scalaire       entier                      Ligne et colonne du point suivant
    SINI, SFIN         scalaire       entier                      Numéro du sommet initial / final
     SOMINI            scalaire       entier       Numéro du sommet initial d’origine (pour revenir au sommet
                                                                d’origine quand il y a fragmentation)
       ZINI            scalaire        réel    Z du sommet initial pour pouvoir orienter l’arc suivant la pente entre
                                                                              SINI et SFIN
ZOLD, ZC, ZNEW         scalaire        réel                     Z du point précédent/courant/suivant
        L              scalaire       entier     Récupération de la valeur dans la matrice P (correspond à la ligne
                                                                          dans la table PVOIS)
    NAXYZINI           scalaire       entier                 Valeur initiale du pointeur de point annexe

Principe :


Dans la matrice Ti,j , pour chaque       , on teste d’abord si ça n’est pas un sommet isolé (cas
où Pi,j = -1) auquel cas, on a juste SXYZ à remplir. Dans le cas général, on compte le nombre
de voisins dans la table VOIS, s’il est égal à 2, on est pas sur un sommet donc on ne le traite
pas tout de suite. Si c’est un sommet, on le stocke puis on parcourt tous ses arcs en suivant les
voisins successifs jusqu’à ce que le nombre de voisins soit différent de 2 auquel cas, c’est le
sommet final de l’arc. A chaque point, on regarde s’il on n’est pas sur un creux/ ou sur une
bosse, si c’est le cas, le point devient un sommet (principe de fragmentation). On oriente tous
les arcs dans le sens d’écoulement de l’eau.


                                                                                                         30
GRAPHE (T,          P, B, Z, X0, Y0, DX, DY, NX, NY,                       VOIS,

NVOIS, PVOIS, NPVOIS, NS, NA, NAXYZ, SXYZ, SIF, AXYZ,

PAXYZ) :            NS    0 ; NA  0 ; NAXYZ  0 ;

               j : 1 Ti,j     ;
         NY          NX
i : 1

Pi,j = -1  C'est un sommet isolé, on récupère simplement ses coordonnées


NS  NS + 1 ; SXYZNS,1           X0 + (j-1) * DX ; SXYZNS,2  Y0 + (i-1) * DY ;

SXYZNS,3        Zi,j ;   

On récupère les valeurs dans la table de pointeurs L      Pi,j ; PD  PVOISL,1 ;

PF  PVOISL,2 ; NV             PF – PD + 1 ; nombre de voisins


NV = 2      C'est un point annexe ou rien, on ne le traite pas pour le moment      C'est

un sommet NS        NS + 1 ; SOMINI  NS ; SINI  SOMINI ; ZINI  Zi,j ;

SXYZNS,1        X0 + (j-1) * DX ; SXYZNS,2  Y0 + (i-1) * DY ; SXYZNS,3  ZINI ;

On traite maintenant les arcs correspondants à ce sommet


                                                                             NV ;
         NV
k : 1        IOLD, JOLD : coordonnées du dernier point étudié NVOLD



PDOLD          PD ; PFOLD  PF ; IOLD  i ; JOLD  j ; ZOLD  ZIOLD,JOLD ;

NPA       0 ; NP  0 ; Ligne et colonne du voisin sur lequel on se place


                                                                                         31
IC  VOISPD+k-1,1 ; JC  VOISPD+k-1,2 ;



     ZC     ZIC,JC ; BIC,JC    On a déjà traité cet arc 2  



on incrémente le compteur de points sur l'arc NP       NP + 1 ;

L    PIC,JC ; PDC  PVOISL,1 ; PFC  PVOISL,2 ; NVC                PFC – PDC + 1 ; nombre de

voisins NVC      2        C'est le sommet final de notre arc NS     NS + 1 ; SFIN  NS ;
SXYZNS,1      X0 + (JC-1) * DX ; SXYZNS,2  Y0 + (IC-1) * DY ; SXYZNS,3  ZIC,JC ;
On a traité cet arc BIOLD,JOLD      ;        On met l'arc dans la table SIF


NA    NA + 1 ;     On oriente l'arc dans le sens de l'écoulement de l'eau ZINI  ZC 


On est dans le bon sens SIFNA,1      SINI ; SIFNA,2  SFIN  C'est le sens inverse

SIFNA,1     SFIN ; SIFNA,2  SINI  On met à jour la table des pointeurs

PAXYZNA,1        NAXYZINI ; PAXYZNA,2  NPA ; NAXYZINI  NAXYZINI + NPA ;
NPA   0;             Ce point a 2 voisins VOISPDC,1 = IOLD        VOISPDC,2 = JOLD 

on est déjà passé sur ce point, on prend l'autre voisin INEW      VOISPDC+1,1 ;

JNEW  VOISPDC+1,2 ; c'est le point suivant INEW            VOISPDC,1 ;

JNEW  VOISPDC,2 ; 


ZNEW        ZINEW,JNEW ;    On regarde le sens d'écoulement sur les 3 points




                                                                                           32
(ZNEW  ZC          ZC  ZOLD)  (ZNEW <               ZC    ZC <    ZOLD)       Pas besoin de

fragmenter (IC – IOLD            INEW – IC)      (JC – JOLD      JNEW – JC)         Nous avons

affaire à un point annexe NPA  NPA + 1 ; NAXYZ            NAXYZ + 1 ;

AXYZNAXYZ,1     X0 + (JC-1)*DX ; AXYZNAXYZ,2  Y0 + (IC-1)*DY ;

AXYZNAXYZ,3  ZC ;            point quelconque, on passe simplement au point suivant       On
fragmente NS    NS + 1 ; SFIN  NS ; SXYZNS,1  X0 + (JC-1)*DX ;

SXYZNS,2  Y0 + (IC-1)*DY ; SXYZNS,3  ZC ; NA  NA + 1 ; On oriente l'arc dans le

sens de l'écoulement de l'eau et on met à jour SIF en conséquence


ZINI  ZC          On est dans le bon sens SIFNA,1      SINI ; SIFNA,2  SFIN           C'est le

sens inverse SIFNA,1       SFIN ; SIFNA,2  SINI  ;    Ce sommet devient le sommet initial du

prochain arc       SINI       SFIN ; ZINI        ZC ; On met à jour la table des pointeurs

PAXYZNA,1    NAXYZINI ; PAXYZNA,2  NPA ;

NAXYZINI     NAXYZINI + NPA ; NPA  0  ;                     Le point que l'on vient de traiter

devient l'ancien point et on passe au suivant IOLD  IC ; JOLD  JC ; ZOLD  ZC ;


PDOLD     PDC ; PFOLD  PFC ; NVOLD  NVC ; IC  INEW ; JC  JNEW 
On repart de notre sommet d'origine SINI        SOMINI ; ZINI  Zi,j ; k j i 




                                                                                                33
Optimiseur d’accès




                     34
Couche graphique

La couche graphique est programmée grâce aux bibliothèques OpenGL directement importées
sur le compilateur Fortran.

  I         Tracé du MNT

   -     Le MNT filaire : procédure CreeListeMNTFil

On trace successivement les lignes où Y=Cste puis où X=Cste.

do i=1, NY-1 ;
   call glBegin(GL_LINE_STRIP) ;
   do j=1, NX-1 ;
         call glVertex3f((j-1)*DX, MatZ(i,j), (i-1)*DY) ;
   enddo ;
   call glEnd() ;
enddo ;
do j=1, NX-1 ;
   call glBegin(GL_LINE_STRIP) ;
          do i=1, NY-1 ;
            call glVertex3f((j-1)*DX, MatZ(i,j), (i-1)*DY) ;
          enddo ;
      call glEnd();
enddo ;




                                                                                    35
                                  Figure 10 : MNT en mode filaire

   -   Le MNT surfacique : procédure CreeListeMNTSurf

On trace les triangles en fonction du maillage (2 triangles par maille)

! Première série de triangles
do i = 1, NY-1 ;
   call glBegin(GL_TRIANGLES)
       do j = 1, NX-1 ;
           P=P+1;
           ! On applique ce vecteur normal au point en dessous
           call glNormal3f (MatN2(P,1), MatN2(P,2), MatN2(P,3));
           call glVertex3f((j-1)*DX, MatZ(i+1,j), (i)*DY) ;
           ! On recommence pour le deuxième point
           call glNormal3f (MatN1(P,1), MatN1(P,2), MatN1(P,3));
           call glVertex3f((j-1)*DX, MatZ(i,j), (i-1)*DY) ;
           ! On recommence pour le troisième point
           call glNormal3f (MatN3(P,1), MatN3(P,2), MatN3(P,3));
           call glVertex3f((j)*DX, MatZ(i,j+1), (i-1)*DY) ;
       enddo ;



                                                                          36
   call glEnd();
enddo;
! Deuxième série de triangles
do i = 1, NY-1 ;
   call glBegin(GL_TRIANGLES)
         do j = 1, NX-1 ;
            P=P+1;
            call glNormal3f (MatN2(P,1), MatN2(P,2), MatN2(P,3));
            call glVertex3f((j-1)*DX, MatZ(i+1,j), (i)*DY) ;
            call glNormal3f (MatN3(P,1), MatN3(P,2), MatN3(P,3));
            call glVertex3f((j)*DX, MatZ(i,j+1), (i-1)*DY) ;
            call glNormal3f (MatN1(P,1), MatN1(P,2), MatN1(P,3));
            call glVertex3f((j)*DX, MatZ(i+1,j+1), (i)*DY) ;
         enddo ;
   call glEnd();
enddo;




                                Figure 11 : MNT en mode surfacique

  II        Tracé du graphe

La procédure TRACER_ARCS dans le module AffichageOpenGL permet d’afficher le
graphe à l’aide des tables SXYZ, SIF, AXYZ et PAXYZ calculées avec les algorithmes vus
précédement.


                                                                                   37
Pour chaque arc, la procédure teste d’abord si l’arc est isolé et trop petit auquel cas il n’est pas
tracé. S’il satisfait le critère, l’arc peut être tracé, deux cas se présentent alors :

   -   l’arc ne comporte pas de points annexes : on trace une ligne simple entre le sommet
       initial et le sommet final en déclarant les deux points.

call glBegin(GL_LINE_STRIP) ;
   NBARC = NBARC + 1;
   call glVertex3f(SXYZ(SINI,1)-X0, SXYZ(SINI,3) + 50.0, SXYZ(SINI,2)-Y0);
   call glVertex3f(SXYZ(SFIN,1)-X0, SXYZ(SFIN,3) + 50.0, SXYZ(SFIN,2)-Y0);
call glEnd();

   -   L’arc comporte des points annexes : on trace d’abord le sommet initial, puis on fait
       une boucle sur la table de points annexes et enfin on termine par le sommet final, le
       mode GL_LINE_STRIP faisant en sorte de relier les points un à un.

call glBegin(GL_LINE_STRIP) ;
   NBARC = NBARC + 1;
   ! on dessine et on parcours tous les points annexes de l'arc
   call glVertex3f(SXYZ(SINI,1)-X0, SXYZ(SINI,3) + 50.0,SXYZ(SINI,2)-Y0);
       do j= PAXYZ(i,1) , PAXYZ(i,1) + NPA-1
           call glVertex3f(AXYZ(j,1)-X0, AXYZ(j,3) + 50.0, AXYZ(j,2)-Y0);
       enddo;
   call glVertex3f(SXYZ(SFIN,1)-X0, SXYZ(SFIN,3) + 50.0, SXYZ(SFIN,2)-Y0);
call glEnd() ;




                              Figure 12 : Affichage du graphe de talweg

Les crêtes/talwegs sont plaqués directement sur le MNT mais on rajoute un ∆Z pour éviter
qu’il y ait un conflit d’affichage entre le MNT et les graphes (ce qui empêcherait de voir la
totalité du graphe).



                                                                                                 38
  III      Anaglyphe

La fonction anaglyphe() calcule un vecteur de translation ana orthogonal au vecteur de visée
cam. Cam est fonction des points cible et d’observation. Ainsi à chaque mouvement du MNT,
cam et ana sont recalculés et les deux MNT rouge et vert sont dessinés ce qui permet la vue
stéreoscopique.

function anaglyphe() result (ana);
        cam = (/x_cible - x_obs, y_cible - y_obs, z_cible - z_obs/) ;
        Y = (/0.,1.,0./) ;
        ana = VECT_PROD (cam, Y)/50 ;

On peut ensuite dessiner deux MNT en mode filaire : un premier rouge et un autre vert
translaté suivant le sens et la direction du vecteur ana.

        call glColor3f(255.0, 0.0, 0.0);
        call glCallList (DessineMNTFil);
        call glColor3f(0.0, 255.0, 0.0);
        ana = anaglyphe ();
        call gltranslatef(ana(1), ana(2), ana(3));
        call glCallList (DessineMNTFilAna);




                                  Figure 13 : vision stéréoscopique


                                                                                         39
   IV     Les fonctions clavier

En plus de l’IHM, il est également possible d’utiliser plusieurs fonctions à l’aide d’un
raccourci clavier. Les flèches directionnelles appellent les primitives de déplacement
(glTranslate), de changement d’échelle (glScale) ou de rotations (glRotate) correspondantes.

Les raccourcis clavier sont :



   V      Les fonctions souris

   VI     Les fonctions de calcul associés au graphisme

Ces fonctions sont regroupées dans les modules ParametresCalcul et Normal. Il s’agit entre
autres des procédures suivantes :

   -    Calcul_Maillage : cette procédure prend en paramètre le nom du fichier de type XYZ
        et détermine à partir de ce fichier les propriétés du maillage ce qui permet de remplir
        une matrice d’altitude MatZ.

   -    Calcul_Matreduite : Prend en entrée un entier N, elle est utilisable pour réduire la
        matrice d’altitude d’une colonne sur N.

   -    Vect_Normal : calcule pour chaque surface son vecteur normal à l’aide d’un produit
        vectoriel.




                                                                                            40
Interface Homme Machine

  I      Aspect général de l’IHM




                                     Figure 14 : IHM

L’IHM peut se décomposer en 4 parties :
   - l’ouverture de fichier
   - le mode d’affichage du MNT
   - la partie crêtes/talwegs
   - les transformations de repère pour se déplacer sur le MNT.


                                                                  41
   II     Ouverture de fichier

Le bouton de chargement du MNT appelle la procédure OuvrirFichier qui renvoie un
booléen : faux si le nom du fichier est une chaîne de caractère vide ou incorrecte ou si
l’utilisateur annule l’ouverture du fichier, vrai sinon. Ce booléen indique si le traitement doit
être interrompu ou pas.




   III    Mode d’affichage

Il s’agit de donner à l’utilisateur de faire le choix entre plusieurs méthodes de représentation,
ainsi, 4 boutons radios font appel aux procédures d’affichage décrites dans la partie
précédente :
     - MNT filiaire : appelle la procédure CreeListeMNTFil pour dessiner le maillage
     - MNT surfacique : appelle la procédure CreeListeMNTSurf pour dessiner le MNT
         triangulé
     - Anaglyphe appelle CreeListeMNTFilAna pour dessiner un second maillage de couleur
         rouge avec un écart réglable :
     - Rien : le MNT n’est pas affiché, cette fonction permet ainsi de ne visualiser que les
         crêtes/talwegs




   IV     Affichage des crêtes/talwegs

Deux cases à cocher permettent d’affecter un identifiant appelé i_cretal, il est égal à :
   - CRE (1) pour les crêtes
   - TAL (2) pour les talwegs
   - CRETAL (3) pour les deux
   - 0 si aucun des deux

L’identifiant i_cretal permet ensuite d’appeler ou non les listes d’affichage des crêtes/talwegs
à savoir :
    - La liste pour afficher les crêtes (IDCRE)
    - La liste pour affiche les talwegs (IDTAL)




                                                                                              42
   V      Transformations

Les rotations peuvent se faire autour des 3 axes (Ox, Oy, Oz), 6 boutons sont pour cela
nécessaires, l’action sur le bouton implique la rotation du repère de – 10° ou de 10° autour de
ces trois axes (ce sont les angles lambda, phi, kappa).

Les translations peuvent là aussi se faire suivant les 3 axes, dans un sens ou dans l’autre :
   - gauche ou droite : translation suivant Ox.
   - haut ou gauche : translation suivant Oy.
   - avant ou arrière : translation suivant Oz.
   - bouton centrer : permet de réinitialiser la position au centre du MNT.




                                                                                                43
Conclusion

Ce projet nous a permis d’écrire des algorithmes de géomatique assez complexes, ce qui a
demandé beaucoup de méthode et de rigueur. De nombreuses difficultés sont intervenues : la
méthode pour amaigrir les matrices de booléens n’a pas été évidente à mettre en œuvre au
départ, la prise de contact avec OpenGL a également posé pas mal de problèmes.

Le rendu final des lignes de crêtes et talwegs peut être sujet à amélioration puisque plusieurs
algorithmes de filtrage et de rattachement ont été écrits mais nous n’avons pas encore réussi à
trouve des critères optimaux pour arriver aux résultats souhaités. De nombreux efforts ont été
consentis pour pouvoir charger des MNT réguliers ou non, mais l’ouverture des fichiers sous
différents formats peut encore être amélioré.




                                                                                            44
Glossaire et sigles utiles




                             45
Sources




          46
Annexes

Le code

Eventuellement la méthode D8




                               47

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:142
posted:7/9/2011
language:French
pages:47