#######################################################################################################################################
#                                                                                                                                     #
#         D I F F U S I O N   B I D I M E N S I O N N E L L E   D Y N A M I Q U E                                                     #
#         D O N T   L A   S O U R C E   E S T   T E L L E   Q U E   M E R   I N I T A L E   E S T   C O N N E X E  :                  #
#                                                                                                                                     #
#                                                                                                                                     #
#         Author of '$xiirk/.DIFF.11.4.$U' :                                                                                          #
#                                                                                                                                     #
#                     Jean-Francois Colonna (LACTAMME, 20140205180726).                                                               #
#                                                                                                                                     #
#######################################################################################################################################

$Z                  @         DoUbLe_dimX = 2 * $dimX
$Z                                      # Introduit le 20070216131711...                                                              #

$Z                  set       X___MeRd=$_____X___Mer
$Z                  set       Y___MeRd=$_____Y___Mer

$Z                  set       X___MeR=`$xci/coordonnees$X normaliser=VRAI abscisse=VRAI ordonnee=FAUX X=$X___MeRd`
$Z                  set       Y___MeR=`$xci/coordonnees$X normaliser=VRAI abscisse=FAUX ordonnee=VRAI Y=$Y___MeRd`

$Z                  set       X_TeRrEd=$_____X_Terre
$Z                  set       Y_TeRrEd=$_____Y_Terre

$Z                  set       X_TeRrE=`$xci/coordonnees$X normaliser=VRAI abscisse=VRAI ordonnee=FAUX X=$X_TeRrEd`
$Z                  set       Y_TeRrE=`$xci/coordonnees$X normaliser=VRAI abscisse=FAUX ordonnee=VRAI Y=$Y_TeRrEd`

$Z                  set       N___MeR=$GRIS_0
$Z                  set       N_TeRrE=$GRIS_8
$Z                  set       N_CoNtOuR=$GRIS_4

$Z                  @                   fXmIn = $Xmin
$Z                  @                   fXmAx = $Xmax + 2
$Z                  @                   fYmIn = $Ymin
$Z                  @                   fYmAx = $Ymax + 2

$Z                  @                   cXmIn = $fXmIn + 1
$Z                  @                   cXmAx = $fXmAx - 1
$Z                  @                   cYmIn = $fYmIn - 1
$Z                  @                   cYmAx = $fYmAx + 2

$c                  #include  <stdio.h>
$c
$c                  #define   N0        _____Premiere
$c                  #define   N         _____Derniere
$c
$c                  int       main()
$c                            {
$c                            int       n;
$c
$c                            for       (n=N0 ; n<=N ; n++)
$c                                      {
$c                                      printf("$xci/S_point$X
$c                                                          A=$DiFfUsIoN.%04d
$c                                                          X=$X___MeRd Y=$Y___MeRd
$c                                                          niveau=$N___MeR
$c                                                          R=$xTV/DIFFUSION.1
$c                                                                                                  $formatI\n"
$c                                            ,n
$c                                             );
$c                                      /* L'image intermediaire '$xTV/DIFFUSION.1' a ete introduite le 20070327165343 pour          */
$c                                      /* eviter un message du genre :                                                              */
$c                                      /*                                                                                           */
$c                                      /*                  Segmentation fault                                                       */
$c                                      /*                                                                                           */
$c                                      /* (alors qu'un "|" devrait suffire en theorie) lorsque le '$formatI' est du type 'Phu'...   */

$c                                      printf("$xci/contours.12$X
$c                                                          A=$xTV/DIFFUSION.1
$c                                                          seuil=$N_CoNtOuR
$c                                                          niveau=$N_TeRrE
$c                                                          X=$X___MeR Y=$Y___MeR
$c                                                          est=VRAI nord=VRAI ouest=VRAI sud=VRAI
$c                                                          nord___est=VRAI nord_ouest=VRAI sud_ouest=VRAI sud___est=VRAI
$c                                                          R=$xTV/PLEINE_MER.1
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Extraction de la pleine mer (ce qui exclue donc les lacs...).                             */
$c                                      /*                                                                                           */
$c                                      /* ATTENTION : dans le cas ou la mer ne serait pas connexe (par exemple cas d'une source     */
$c                                      /* coupant en deux l'espace), l'operation precedente de remplissage de contours doit etre    */
$c                                      /* faite autant de fois qu'il y a de composantes ; ensuite '$xTV/PLEINE_MER.1' sera calculee */
$c                                      /* comme l'union (par '$xci/or_02$X') de tous ces remplissages...                            */
$c                                      /*                                                                                           */
$c                                      /* ATTENTION : on notera que l'on force a 'N___MeR' le point {$X___MeRd,$Y___MeRd} pour ne   */
$c                                      /* "pieger" ensuite '$xci/contours.12$X'...                                                  */

$c                                      printf("$xci/S_point$X
$c                                                          A=$DiFfUsIoN.%04d
$c                                                          X=$X_TeRrEd Y=$Y_TeRrEd
$c                                                          niveau=$N_TeRrE
$c                                                                                                  $formatI  |
$c                                              $xci/complement$X
$c                                                          R=$xTV/DIFFUSION.2
$c                                                                                                  $formatI\n"
$c                                            ,n
$c                                             );
$c                                      /* L'image intermediaire '$xTV/DIFFUSION.2' a ete introduite le 20070327165343 pour          */
$c                                      /* eviter un message du genre :                                                              */
$c                                      /*                                                                                           */
$c                                      /*                  Segmentation fault                                                       */
$c                                      /*                                                                                           */
$c                                      /* (alors qu'un "|" devrait suffire en theorie) lorsque le '$formatI' est du type 'Phu'...   */

$c                                      printf("$xci/contours.12$X
$c                                                          A=$xTV/DIFFUSION.2
$c                                                          seuil=$N_CoNtOuR
$c                                                          niveau=$N_TeRrE
$c                                                          X=$X_TeRrE Y=$Y_TeRrE
$c                                                          est=VRAI nord=VRAI ouest=VRAI sud=VRAI
$c                                                          nord___est=FAUX nord_ouest=FAUX sud_ouest=FAUX sud___est=FAUX
$c                                                          R=$xTV/TERRE_FERME.1
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Extraction de la terre ferme (ce qui exclue donc les iles, mais inclue des lacs...).      */
$c                                      /*                                                                                           */
$c                                      /* ATTENTION : dans le cas ou la terre ne serait pas connexe, l'operation precedente de      */
$c                                      /* remplissage de contours doit etre faite autant de fois qu'il y a de composantes ; ensuite */
$c                                      /* '$xTV/TERRE_FERME.1' sera calculee comme l'union (par '$xci/or_02$X') de tous ces         */
$c                                      /* remplissages...                                                                           */
$c                                      /*                                                                                           */
$c                                      /* ATTENTION : on notera que l'on force a '$N_TeRrE' le point {$X_TeRrEd,$Y_TeRrEd} pour ne  */
$c                                      /* "pieger" ensuite '$xci/contours.12$X'...                                                  */

$c                                      printf("$xci/eor$X
$c                                                          A1=$DiFfUsIoN.%04d
$c                                                          A2=$xTV/TERRE_FERME.1
$c                                                          R=$xTV/ILES.1
$c                                                                                                  $formatI\n"
$c                                            ,n
$c                                             );
$c                                      /* Extraction des iles seules...                                                             */

$c                                      printf("$xci/complement$X
$c                                                          A=$DiFfUsIoN.%04d
$c                                                                                                  $formatI  |
$c                                              $xci/eor$X
$c                                                          A1=$xTV/PLEINE_MER.1
$c                                                          R=$xTV/LACS.1
$c                                                                                                  $formatI\n"
$c                                            ,n
$c                                             );
$c                                      /* Extraction des lacs seuls...                                                              */

$c                                      printf("$xci/or_02$X
$c                                                          A1=$xTV/TERRE_FERME.1
$c                                                          A2=$xTV/LACS.1
$c                                                                                                  $formatI  |
$c                                              $xci/eor$X
$c                                                          A1=$xTV/ILES.1
$c                                                                                                  $formatI  |
$c                                              $xci/complement$X
$c                                                          R=$xTV/TERRE_FERME_LACS_COMBLES.1
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Extraction la terre ferme tous les lacs ayant ete bouches...                              */

$c                                      printf("$xci/format.01$X
$c                                                          A=$xTV/TERRE_FERME_LACS_COMBLES.1
$c                                                                              $formatI
$c                                                          mode=7
$c                                                          R=$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.1
$c                                                                              XminR=$fXmIn XmaxR=$fXmAx YminR=$fYmIn YmaxR=$fYmAx\n"
$c                                             );

$c                                      printf("XYmaxNe             $fXmAx $fYmAx\n");

$c                                      printf("$xci/bordurage.11$X
$c                                                          A=$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.1
$c                                                          Xbg=$cXmIn Ybg=$cYmIn
$c                                                          Xhd=$cXmAx Yhd=$cYmAx
$c                                                                                                  $formatI  |
$c                                              $xci/or_02$X
$c                                                          A1=$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.1
$c                                                          R=$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Le "bordurage" est destine a etendre l'image '$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.1'   */
$c                                      /* sur son pourtour. Rappelons qu'elle est immergee dans un espace faisant un point de plus  */
$c                                      /* a droite, a gauche, en bas et en haut. Le "bordurage" remplit donc cet "entourage" (d'un  */
$c                                      /* point d'epaisseur) en fonction du bord de '$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.1' de   */
$c                                      /* telle sorte que les proprietes topologiques soient conservees en vue de l'extraction de   */
$c                                      /* contour qui va suivre...                                                                  */

$c                                      printf("$xci/contours.11$X
$c                                                          A=$xTV/TERRE_FERME_LACS_COMBLES_BORDUREE.2
$c                                                          seuil=$N_CoNtOuR
$c                                                          niveau=$N_TeRrE
$c                                                          X=$X_TeRrE Y=$Y_TeRrE
$c                                                          nombre_minimal_de_points=$DoUbLe_dimX
$c                                                          load_niveau_hors_image=$N_TeRrE
$c                                                          points_contour=FAUX
$c                                                          R=$xTV/PLAGE_BORDUREE
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Extraction de la plage. On notera que l'exterieur du champ est declare comme appartenant  */
$c                                      /* a l'interieur du contour que l'on extrait ("load_niveau_hors_image=$N_TeRrE"). Cela fait  */
$c                                      /* que la plage va faire le tour de l'image par le bas, ce qui justifie le fait que la plage */
$c                                      /* est extraite dans un domaine superieur d'un point (dans les 4 directions) au domaine      */
$c                                      /* 'Pal'. La partie de la plage situee en bas disparaitra lors du retour au format 'Pal'...  */
$c                                      /*                                                                                           */
$c                                      /* Le 20070215131551 fut introduit "nombre_minimal_de_points=$dimX" a cause du probleme dit  */
$c                                      /* "des impasses" ('v $xiii/contours$FON 20070214153034'), la valeur '$dimX' venant du fait  */
$c                                      /* que la source est une ligne horizontale traversant l'image et qu'ainsi le contour (qui    */
$c                                      /* correspond a la plage) est necessairement plus "long" que '$dimX' (et meme que son double */
$c                                      /* puisqu'il est ferme, d'ou le passage de '$dimX' a '$DoUbLe_dimX' le 20070216131711...).   */

$c                                      printf("$xci/format.01$X
$c                                                          A=$xTV/PLAGE_BORDUREE
$c                                                                                                 $formatI
$c                                                          mode=7
$c                                                          R=$xTV/PLAGE.1
#20070320143756____:$c                                                                                            $formatR_Pal\n"     #
$c                                                                                                           $FoRmAtR\n"
$c                                             );

#20070320143756____:$c                                      printf("Pal\n");                                                          #
$c                                      printf("eval      $_____FoRmAt\n");

$c                                      printf("$xci/eor$X
$c                                                          A1=$xTV/TERRE_FERME.1
$c                                                          A2=$xTV/PLAGE.1
$c                                                          R=$xTV/TERRE_FERME_SANS_LA_PLAGE.1
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Extraction de la terre ferme sans la plage...                                             */

$c                                      printf("$xci/acces$X
$c                                                          A=$xTV/PLAGE.1
$c                                                          renormaliser=VRAI rBLANC=$_____Plage
$c                                                          CAL1=FAUX
$c                                                          R=$xTV/PLAGE.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Coloriage de la plage...                                                                  */

$c                                      printf("$xci/acces$X
$c                                                          A=$xTV/PLEINE_MER.1
$c                                                          renormaliser=VRAI rBLANC=$_____PleineMer
$c                                                          CAL1=FAUX
$c                                                          R=$xTV/PLEINE_MER.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Coloriage de la pleine mer...                                                             */

$c                                      printf("$xci/acces$X
$c                                                          A=$xTV/LACS.1
$c                                                          renormaliser=VRAI rBLANC=$_____Lacs
$c                                                          CAL1=FAUX
$c                                                          R=$xTV/LACS.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Coloriage des lacs...                                                                     */

$c                                      printf("$xci/acces$X
$c                                                          A=$xTV/TERRE_FERME_SANS_LA_PLAGE.1
$c                                                          renormaliser=VRAI rBLANC=$_____TerreFerme
$c                                                          CAL1=FAUX
$c                                                          R=$xTV/TERRE_FERME_SANS_LA_PLAGE.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Coloriage de la terre ferme...                                                            */

$c                                      printf("$xci/acces$X
$c                                                          A=$xTV/ILES.1
$c                                                          renormaliser=VRAI rBLANC=$_____Iles
$c                                                          CAL1=FAUX
$c                                                          R=$xTV/ILES.2
$c                                                                                                  $formatI\n"
$c                                             );
$c                                      /* Coloriage des iles...                                                                     */

$c                                      printf("$xci/or_02$X
$c                                                          A1=$xTV/PLAGE.2
$c                                                          A2=$xTV/TERRE_FERME_SANS_LA_PLAGE.2
$c                                                                                                  $formatI  |
$c                                              $xci/or_02$X
$c                                                          A2=$xTV/ILES.2
$c                                                                                                  $formatI  |
$c                                              $xci/or_02$X
$c                                                          A2=$xTV/PLEINE_MER.2
$c                                                                                                  $formatI  |
$c                                              $xci/or_02$X
$c                                                          A2=$xTV/LACS.2
$c                                                          R=$_____images.%04d
$c                                                                                                  $formatI\n"
$c                                            ,n
$c                                             );
$c                                      /* Extraction la terre ferme tous les lacs ayant ete bouches.                                */
$c                                      }
$c                            }



Copyright © Jean-François Colonna, 2019-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019-2021.