#!/bin/csh

#######################################################################################################################################
#                                                                                                                                     #
#         V I S U A L I S A T I O N   D ' U N E   S U R F A C E   A V E C   D E S   P A R T I C U L E S  :                            #
#                                                                                                                                     #
#                                                                                                                                     #
#         Utilisation :                                                                                                               #
#                                                                                                                                     #
#    $xrs/SurfParti.01$Z <Gen> <ImageR> [<PerU> [<PerV> [<FacPas> [<Deriv> [<GArg> [<PArg> [<I> [<X> [<Y> [<Z> [<P> [<FR>]]]]]]]]]]]] #
#                                                                                                                                     #
#                                                                                                                                     #
#         Author of '$xrs/SurfParti.01$Z' :                                                                                           #
#                                                                                                                                     #
#                     Jean-Francois Colonna (LACTAMME, 20060413092611).                                                               #
#                                                                                                                                     #
#######################################################################################################################################

set       Generateur=$1
                                        # On notera le 20060427153922 que '$Generateur' peut etre '$xrs/project2D.11$X' ; dans ce     #
                                        # cas, il convient que l'argument '$GArguments' (ci-apres...) contiennent obligatoirement     #
                                        # les parametres suivants :                                                                   #
                                        #                                                                                             #
                                        #                   imageFx=                                                                  #
                                        #                   imageFy=                                                                  #
                                        #                   imageFz=                                                                  #
                                        #                                                                                             #
                                        # et d'autres eventuellement utiles...                                                        #
set       ImageR=$2
set       PeriodiserU=$3
set       PeriodiserV=$4
                                        # Les periodisations eventuelles de 'u' et 'v' ont ete introduites le 20060417123139...       #
set       FacteurPas=$5
set       Derivees=$6
set       GArguments=($7)
                                        # Ce parametre permet d'introduire une liste quelconque de parametres de la commande          #
                                        # '$Generateur' (voir ci-dessus le cas de '$xrs/project2D.11$X'...).                          #
set       PArguments=($8)
                                        # Ce parametre permet d'introduire une liste quelconque de parametres de la commande          #
                                        # '$xrv/particule.10$X' et par exemple :                                                      #
                                        #                                                                                             #
                                        #                   "N_AU_CARRE=FAUX LISTE_RAYON=0.01 ZOOM=1"                                 #
                                        #                                                                                             #
set       Inversion=$9
set       XInversion=$10
set       YInversion=$11
set       ZInversion=$12
set       PInversion=$13
                                        # La possibilite de faire une inversion geometrique a ete introduite le 20060426102457...     #
set       ForcerRayonI=$14
                                        # La possibilite de forcer le rayon d'inversion a ete introduite le 20080401141309...         #

setArgum  PeriodiserU                   `GetParam $xrv/maillage_u_v$X "periodiser_U"`
                                        # Introduit le 20060426101033...                                                              #

setArgum  PeriodiserV                   `GetParam $xrv/maillage_u_v$X "periodiser_V"`
                                        # Introduit le 20060426101033...                                                              #

setArgum  FacteurPas                    10

setArgum  Derivees                      0
                                        # La valeur nulle par defaut permet de transformer les surfaces en polyhedre...               #

setArgum  Inversion                     $NEXIST

setArgum  XInversion                    `GetParam $xrv/inversion.01$X "Xpole"`

setArgum  YInversion                    `GetParam $xrv/inversion.01$X "Ypole"`

setArgum  ZInversion                    `GetParam $xrv/inversion.01$X "Zpole"`

setArgum  PInversion                    `GetParam $xrv/inversion.01$X "puissance"`

set       GenerateurEffectif=$Generateur

if        (! -e $GenerateurEffectif) then
                                        # Introduit le 20051217182832 afin de permettre de donner le '$xrs' ou pas...                 #
          set       GenerateurEffectif=$xrs/$GenerateurEffectif
                                        # Introduit le 20051010140027 afin de permettre de donner le '$X' ou pas...                   #

          if        (! -e $GenerateurEffectif) then
                    set       GenerateurEffectif=$GenerateurEffectif$X
          else
          endif
else
endif

if        (-e $GenerateurEffectif) then
          FileTmpB  imageT
          FileTmpB  LiStE_P1

          set       PaS_u=`GetParam $GenerateurEffectif "pu"`
          set       PaS_v=`GetParam $GenerateurEffectif "pv"`
                                        # Recuperation des pas par defaut en {u,v}.                                                   #

          set       PaS_u=`calcul $FacteurPas*$PaS_u`
          set       PaS_v=`calcul $FacteurPas*$PaS_v`
                                        # Calcul des pas effectifs en {u,v}.                                                          #

          $GenerateurEffectif                                                                                                           \
                              pu=$PaS_u pv=$PaS_v                                                                                       \
                              lister_les_points=VRAI lister_les_points_avant=VRAI lister_u_et_v=VRAI                                    \
                              ZOOM=1                                                                                                    \
                              $GArguments                                                                                               \
                              R=$imageT chiffres=0                                                                                      \
                              extrema_hors=FAUX                                                                                         \
                                                                                                    $formatI                      |     \
          $SE       -e "s/^/ /"                                                                                                         \
                                                                                                    > $LiStE_P1
                                        # Generation de la liste des points...                                                        #
                                        #                                                                                             #
                                        # Le "extrema_hors=FAUX" est destine a eliminer les messages d'avertissement sur les          #
                                        # coordonnees hors-previsions...                                                              #

          FileTmpE  imageT

          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(U=[^ ]*\) .*$/\1/'                                                                                      \
                    -e 's/U=//'                                                                                                         \
                                                                                                    > $LiStE_P1.u
          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(V=[^ ]*\) .*$/\1/'                                                                                      \
                    -e 's/V=//'                                                                                                         \
                                                                                                    > $LiStE_P1.v
                                        # Generation de la liste des coordonnees {u,v}.                                               #

          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(X=[^ ]*\) .*$/\1/'                                                                                      \
                    -e 's/X=//'                                                                                                         \
                                                                                                    > $LiStE_P1$COORD_X
          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(Y=[^ ]*\) .*$/\1/'                                                                                      \
                    -e 's/Y=//'                                                                                                         \
                                                                                                    > $LiStE_P1$COORD_Y
          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(Z=[^ ]*\) .*$/\1/'                                                                                      \
                    -e 's/Z=//'                                                                                                         \
                                                                                                    > $LiStE_P1$COORD_Z
                                        # Generation de la liste des coordonnees {X,Y,Z}.                                             #

          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(ROUGE=[^ ]*\) .*$/\1/'                                                                                  \
                    -e 's/ROUGE=//'                                                                                                     \
                                                                                                    > $LiStE_P1$ROUGE
          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(VERTE=[^ ]*\) .*$/\1/'                                                                                  \
                    -e 's/VERTE=//'                                                                                                     \
                                                                                                    > $LiStE_P1$VERTE
          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(BLEUE=[^ ]*\) .*$/\1/'                                                                                  \
                    -e 's/BLEUE=//'                                                                                                     \
                                                                                                    > $LiStE_P1$BLEUE
                                        # Generation de la liste des couleurs {R,V,B}.                                                #

          $CA       $LiStE_P1                                                                                                     |     \
          $SE       -e 's/^.* \(RAYON=[^ ]*\) .*$/\1/'                                                                                  \
                    -e 's/RAYON=//'                                                                                                     \
                                                                                                    > $LiStE_P1.r
                                        # Generation de la liste des RAYONs au cas ou (introduit le 20060426101033)...                #

          FileTmpB  LiStE_P2
          FileTmpB  LiStE_P3

          set       Parametres_uv="$K_VIDE"
          set       Parametres_uv="$Parametres_uv"" ne=0"
          set       Parametres_uv="$Parametres_uv"" fichierU=$LiStE_P1.u"
          set       Parametres_uv="$Parametres_uv"" fichierV=$LiStE_P1.v"
          set       Parametres_uv="$Parametres_uv"" periodiser_U=$PeriodiserU"
          set       Parametres_uv="$Parametres_uv"" periodiser_V=$PeriodiserV"
                                        # Introduit le 20060414090053 pour simplifier la suite...                                     #
          set       Parametres_uv="$Parametres_uv"" suites_non_monotones=VRAI"
                                        # Introduit le 20091102115701 au cas ou...                                                    #

          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$COORD_X                                                                                \
                                                                                                    > $LiStE_P2$COORD_X
          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$COORD_Y                                                                                \
                                                                                                    > $LiStE_P2$COORD_Y
          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$COORD_Z                                                                                \
                                                                                                    > $LiStE_P2$COORD_Z
                                        # Generation de la liste des coordonnees {X,Y,Z} du maillage...                               #

          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$ROUGE                                                                                  \
                                                                                                    > $LiStE_P3$ROUGE
          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$VERTE                                                                                  \
                                                                                                    > $LiStE_P3$VERTE
          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1$BLEUE                                                                                  \
                                                                                                    > $LiStE_P3$BLEUE
                                        # Generation de la liste des couleurs {R,V,B} du maillage...                                  #

          $xrv/maillage_u_v$X                                                                                                           \
                              $Parametres_uv                                                                                            \
                              fichierS=$LiStE_P1.r                                                                                      \
                                                                                                    > $LiStE_P2.r
                                        # Generation de la liste des RAYONs du maillage au cas ou (introduit le 20060426101033)...    #

          if        ($Inversion == $NEXIST) then
                                        # La possibilite de faire une inversion geometrique a ete introduite le 20060426102457...     #
                    $xrv/neutre$X                                                                                                       \
                                        ne=0                                                                                            \
                                        fichier=$LiStE_P2$COORD_X                                                                       \
                                                                                                              > $LiStE_P3$COORD_X
                    $xrv/neutre$X                                                                                                       \
                                        ne=0                                                                                            \
                                        fichier=$LiStE_P2$COORD_Y                                                                       \
                                                                                                              > $LiStE_P3$COORD_Y
                    $xrv/neutre$X                                                                                                       \
                                        ne=0                                                                                            \
                                        fichier=$LiStE_P2$COORD_Z                                                                       \
                                                                                                              > $LiStE_P3$COORD_Z

                    set       LiStE_RaYoN="$K_VIDE"
                                        # Les RAYONs ne sont pas utilises lorsqu'il n'y a pas inversion...                            #
          else
                                        # La possibilite de faire une inversion geometrique a ete introduite le 20060426102457...     #
                    set       Parametres_Inv="$K_VIDE"
                    set       Parametres_Inv="$Parametres_Inv"" ne=0"
                    set       Parametres_Inv="$Parametres_Inv"" Xpole=$XInversion"
                    set       Parametres_Inv="$Parametres_Inv"" Ypole=$YInversion"
                    set       Parametres_Inv="$Parametres_Inv"" Zpole=$ZInversion"
                    set       Parametres_Inv="$Parametres_Inv"" puissance=$PInversion"
                    set       Parametres_Inv="$Parametres_Inv"" LISTE_X=$LiStE_P2$COORD_X"
                    set       Parametres_Inv="$Parametres_Inv"" LISTE_Y=$LiStE_P2$COORD_Y"
                    set       Parametres_Inv="$Parametres_Inv"" LISTE_Z=$LiStE_P2$COORD_Z"

                    if        ("$ForcerRayonI" == "$K_VIDE") then
                              set       Parametres_Inv="$Parametres_Inv"" LISTE_RAYON=$LiStE_P2.r"
                    else
                              set       Parametres_Inv="$Parametres_Inv"" LISTE_RAYON=$ForcerRayonI"
                                        # Possibilite introduite le 20080401141309...                                                 #
                    endif

                    $xrv/inversion.01$X                                                                                                 \
                                        $Parametres_Inv                                                                                 \
                                        pX=1 pY=0 pZ=0 pRAYON=0                                                                         \
                                                                                                              > $LiStE_P3$COORD_X
                    $xrv/inversion.01$X                                                                                                 \
                                        $Parametres_Inv                                                                                 \
                                        pX=0 pY=1 pZ=0 pRAYON=0                                                                         \
                                                                                                              > $LiStE_P3$COORD_Y
                    $xrv/inversion.01$X                                                                                                 \
                                        $Parametres_Inv                                                                                 \
                                        pX=0 pY=0 pZ=1 pRAYON=0                                                                         \
                                                                                                              > $LiStE_P3$COORD_Z
                    $xrv/inversion.01$X                                                                                                 \
                                        $Parametres_Inv                                                                                 \
                                        pX=0 pY=0 pZ=0 pRAYON=1                                                                         \
                                                                                                              > $LiStE_P3.r

                    set       LiStE_RaYoN="LISTE_RAYON=$LiStE_P3.r"
                                        # Les RAYONs sont utilises lorsqu'il y a inversion...                                         #
          endif

          set       NPointsX=`$CA $LiStE_P3$COORD_X | $WCl`
          set       NPointsY=`$CA $LiStE_P3$COORD_Y | $WCl`
          set       NPointsZ=`$CA $LiStE_P3$COORD_Z | $WCl`
          set       NPointsXYZ=`$xcg/MAX3.01$X x=$NPointsX y=$NPointsY z=$NPointsZ entier=VRAI`

          $xrv/particule.10$X np=1 iterations=$NPointsXYZ                                                                               \
                              coordonnees_dans_0_1=VRAI                                                                                 \
                              AXYZ=1 BXYZ=0                                                                                             \
                              zoom_automatique=FAUX                                                                                     \
                              LISTE_X=$LiStE_P3$COORD_X                                                                                 \
                              LISTE_Y=$LiStE_P3$COORD_Y                                                                                 \
                              LISTE_Z=$LiStE_P3$COORD_Z                                                                                 \
                              LISTE_ROUGE=$LiStE_P3$ROUGE                                                                               \
                              LISTE_VERTE=$LiStE_P3$VERTE                                                                               \
                              LISTE_BLEUE=$LiStE_P3$BLEUE                                                                               \
                              $LiStE_RaYoN                                                                                              \
                              Lz=1000                                                                                                   \
                              isoles=FAUX chainer=FAUX                                                                                  \
                              ajuster_points=VRAI equidistance=VRAI                                                                     \
                              cubique=VRAI LISTE_dX=$Derivees LISTE_dY=$Derivees LISTE_dZ=$Derivees                                     \
                              RVB=VRAI                                                                                                  \
                              extrema_hors=FAUX                                                                                         \
                              $PArguments                                                                                               \
                              R=$ImageR                                                                                                 \
                              chiffres=0                                                                                                \
                                                                                                    $formatI
                                        # Et enfin, visualisation de la surface...                                                    #

          FileTmpE  LiStE_P1
          FileTmpE  LiStE_P2
          FileTmpE  LiStE_P3
                                        # Nettoyage...                                                                                #
else
          EROR      "Le generateur de surface '$Generateur' n'existe pas."
endif



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