/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A U T O M A T E   C E L L U L A I R E   M O N O D I M E N S I O N N E L  :                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Cette commande genere une image                                                                                */
/*                  dont le nom est le premier argument                                                                              */
/*                  d'appel ; elle est le resultat de                                                                                */
/*                  l'evolution de la premiere ligne de                                                                              */
/*                  l'image Argument a l'aide de l'automate                                                                          */
/*                  cellulaire monodimensionnel Argument.                                                                            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xci/AutoC_1DQ.01$K' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20021002135359).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N T E R F A C E   ' listG '  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        :Debut_listG:                                                                                                              */
/*        :Fin_listG:                                                                                                                */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I R E C T I V E S   S P E C I F I Q U E S   D E   C O M P I L A T I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_BASE
#include  image_image_IMAGESF_EXT

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/sequence.01.I"
                                        /* ATTENTION, on definit ainsi le symbole 'DERNIERE_IMAGE' qui ne sert a rien ici, puisque   */
                                        /* c'est en effet 'Zmax' qui joue ce role...                                                 */
#include  xci/substitue.01.I"
                                        /* Introduit le 20021005212108...                                                            */

#define   FORCER_L_EXECUTION_EN_CAS_D_ERREUR_DE_LECTURE_DE_L_ALBUM_DE_L_AUTOMATE_CELLULAIRE                                             \
                    FAUX                                                                                                                \
                                        /* Indicateur introduit le 20021004153954 qui permet d'executer le processus de l'automate   */ \
                                        /* cellulaire meme si l'album le definissant est incomplet, voire absent.                    */

#define   VALEUR_PAR_DEFAUT_DE_L_AUTOMATE_CELLULAIRE                                                                                    \
                    BLANC                                                                                                               \
                                        /* Valeur a donner a l'automate cellulaire lorsque 'nom_imageP' est absent.                  */

#define   PERTURBER_ALEATOIREMENT                                                                                                       \
                    FAUX
#define   SEUIL_DE_PERTURBATION_ALEATOIRE                                                                                               \
                    PROBABILITE_NULLE
                                        /* Afin de pouvoir perturber aleatoirement l'automate cellulaire et ce de facon locale       */
                                        /* (introduit sous cette forme le 20081207170255). On notera que cette valeur est            */
                                        /* destinee a initialiser par defaut l'image 'champ_de_perturbation_aleatoire'...            */

#define   COMPATIBILITE_20081206                                                                                                        \
                    FAUX                                                                                                                \
                                        /* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement   */ \
                                        /* au 20081206120905.                                                                        */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/substitue.02.I"
                                        /* Introduit le 20021005212108...                                                            */

#define   champ_de_perturbation_aleatoire                                                                                               \
                    IFmageA

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A U T O M A T E   C E L L U L A I R E   M O N O D I M E N S I O N N E L  :                                                 */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageC),NOM_UNDEF));
                                        /* Le 20081208110105 'NOM_UNDEF' a remplace 'NOM_PIPE' pour 'nom_imageC'...                  */

#include  xci/substitue.03.I"
                                        /* Introduit le 20021005212108...                                                            */

     DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
                                        /* Nom d'un eventuel postfixe a placer derriere <nom_imageC><numero> (par exemple '$ROUGE'). */
     DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
                                        /* Numero de la premiere image,                                                              */
     DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
                                        /* Pas de passage d'un numero d'image a une autre.                                           */
     DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
                                        /* Nombre de chiffres codant le numero des images de la serie...                             */
     DEFV(Logical,INIT(forcer_l_execution_en_cas_d_erreur_de_lecture_de_l_album_de_l_automate_cellulaire
                      ,FORCER_L_EXECUTION_EN_CAS_D_ERREUR_DE_LECTURE_DE_L_ALBUM_DE_L_AUTOMATE_CELLULAIRE
                       )
          );
                                        /* Indicateur introduit le 20021004153954 qui permet d'executer le processus de l'automate   */
                                        /* cellulaire meme si l'album le definissant est incomplet, voire absent.                    */

     DEFV(genere_p,INIT(valeur_par_defaut_de_l_automate_cellulaire,VALEUR_PAR_DEFAUT_DE_L_AUTOMATE_CELLULAIRE));
                                        /* Valeur a donner a l'automate cellulaire lorsque 'nom_imageP' est absent.                  */

     DEFV(Int,INIT(Ymin_de_l_automate_cellulaire_monodimensionnel,UNDEF));
     DEFV(Int,INIT(Ymax_de_l_automate_cellulaire_monodimensionnel,UNDEF));
                                        /* Definition des extrema de la coordonnee 'Y'. Evidemment, en general, il s'agira de        */
                                        /* {Ymin,Ymax} ; mais des valeurs differentes permettront de repartir d'un automate          */
                                        /* "partiel" anterieur et ainsi de changer la definition de 'automate_cellulaire' au cours   */
                                        /* de la generation. On pourra ainsi faire, par exemple, les 'N1' premieres lignes avec      */
                                        /* 'AUTOMATE1', puis les 'N2' lignes suivantes avec 'AUTOMATE2',... Ceci fut introduit le    */
                                        /* 20081013110147...                                                                         */

     DEFV(Logical,INIT(perturber_aleatoirement,PERTURBER_ALEATOIREMENT));
     DEFV(Float,INIT(seuil_de_perturbation_aleatoire,SEUIL_DE_PERTURBATION_ALEATOIRE));
                                        /* Afin de pouvoir perturber aleatoirement l'automate cellulaire et ce de facon locale       */
                                        /* (introduit sous cette forme le 20081207170255). On notera que cette valeur est            */
                                        /* destinee a initialiser par defaut l'image 'champ_de_perturbation_aleatoire'...            */
     DEFV(CHAR,INIC(POINTERc(nom_imageP),NOM_UNDEF));
                                        /* On notera que lorsque 'nom_imageP' n'est pas specifie explicitement, c'est alors la       */
                                        /* valeur de 'seuil_de_perturbation_aleatoire' qui permet de proceder a l'initialisation     */
                                        /* de 'champ_de_perturbation_aleatoire'...                                                   */

     DEFV(Logical,INIT(compatibilite_20081206,COMPATIBILITE_20081206));
                                        /* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement   */
                                        /* au 20081206120905.                                                                        */
     /*..............................................................................................................................*/
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_L("compatibilite_20081206=",compatibilite_20081206);

                         GET_ARGUMENT_C("imageA=""A=",nom_imageA);
                         GET_ARGUMENT_C("imageC=""automate=""C=",nom_imageC);
                         GET_ARGUMENT_C("imageR=""R=",nom_imageR);
                         GET_ARGUMENT_C("imageP=""P=",nom_imageP);
                         GET_ARGUMENT_C("postfixe=",nom_postfixe);
                         GET_ARGUMENT_I("premiere=",premiere_image);
                         GET_ARGUMENTS2_I("pas=",pas_des_images,pasZ);
                                        /* L'argument 'pasZ' fut introduit le 20110119140223...                                      */
                         GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
                         GET_ARGUMENT_L("forcer=",forcer_l_execution_en_cas_d_erreur_de_lecture_de_l_album_de_l_automate_cellulaire);

                         GET_ARGUMENT_P("vd=""defaut=",valeur_par_defaut_de_l_automate_cellulaire);
                         GET_ARGUMENT_P("vb=""bord=",Iautomate_cellulaire_monodimensionnel_____niveau_hors_processus);

                         GET_ARGUMENT_I("N_voisins=""Nv=",Iautomate_cellulaire_monodimensionnel_____N_voisins);
                                        /* Parametres introduits le 20081125184932...                                                */

                         GET_ARGUMENT_L("periodiser_X=""per_X=",Iautomate_cellulaire_monodimensionnel_____periodiser_X);
                         GET_ARGUMENT_L("symetriser_X=""sym_X=",Iautomate_cellulaire_monodimensionnel_____symetriser_X);
                         GET_ARGUMENT_L("prolonger_X=""pro_X=",Iautomate_cellulaire_monodimensionnel_____prolonger_X);
                                        /* Parametres introduits le 20081121181745...                                                */

                         GET_ARGUMENT_L("editer_les_messages_de_hors_image=""editer_messages="
                                       ,Iautomate_cellulaire_monodimensionnel_____editer_les_messages_de_hors_image
                                        );
                                        /* Parametres introduits le 20081118135755...                                                */

                         GET_ARGUMENT_C("substitution=""s=",nom_substitution);
                         GET_ARGUMENT_C("paletteA=""palette=""pA=""p=",nom_paletteA);
                                        /* Parametres mis ici le 20021002135359 en supprimant {seuil_bas,seuil_haut}...              */

                         GET_ARGUMENT_L("perturber_aleatoirement=""aleatoire=""pa=",perturber_aleatoirement);
                         GET_ARGUMENT_F("seuil_de_perturbation_aleatoire=""seuil=""spa=",seuil_de_perturbation_aleatoire);
                         GET_ARGUMENT_I("graine=""g="
                                       ,Iautomate_cellulaire_monodimensionnel_____graine_de_perturbation_aleatoire
                                        );
                         GET_ARGUMENT_I("graine_Gauche=""gG=""gg="
                                       ,Iautomate_cellulaire_monodimensionnel_____graine_du_niveau_du_point_Gauche__anterieur
                                        );
                         GET_ARGUMENT_I("graine_Droite=""gD=""gd="
                                       ,Iautomate_cellulaire_monodimensionnel_____graine_du_niveau_du_point_Droite__anterieur
                                        );
                                        /* Parametres introduits le 20081205172947...                                                */

                         GIT_ARGUMENT_I("YminA=""Ym=",Ymin_de_l_automate_cellulaire_monodimensionnel,Ymin);
                         GIT_ARGUMENT_I("YmaxA=""YM=",Ymax_de_l_automate_cellulaire_monodimensionnel,Ymax);
                                        /* Parametres introduits le 20081013110147...                                                */
                         )
                    );

     CALi(Inoir(ImageR));
                                        /* Initialisation de l'image Resultat.                                                       */

     Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageA))))
                                        /* Chargement de la premiere image Argument.                                                 */
          Bblock
          DEFV(automate_cellulaire_monodimensionnel,automate_cellulaire);
                                        /* Automate cellulaire...                                                                    */

          Test(IL_NE_FAUT_PAS(compatibilite_20081206))
                                        /* Test introduit le 20081206120905...                                                       */
               Bblock
#include  xci/substitue.05.I"
                                        /* Introduit le 20021005212108. Le 20081206092901 '$xci/substitue.04$I', reference par       */
                                        /* erreur (lors d'une introduction quasi-automatique des ces "include"s dans differents      */
                                        /* '$K's), a ete remplace par '$xci/substitue.05$I'. D'ailleurs, a cette date, je ne         */
                                        /* comprends toujours pas a quoi ces "include"s servaient avant le 20081205180232...         */
                                        /*                                                                                           */
                                        /* Le 20081206093712, l'experience consistant a recalculer l'image 'v $xiird/AC1C.B1' a ete  */
                                        /* faite en ajoutant les parametres :                                                        */
                                        /*                                                                                           */
                                        /*                  substitution=L_SUBSTITUTION_ROUGE                                        */
                                        /*                  p=$xiP/binaire.01                                                        */
                                        /*                                                                                           */
                                        /* cette image ayant ete choisie parce qu'elle est complexe et qu'elle utilise tous les      */
                                        /* niveaux de gris. Le resultat a ete sans appel : l'image calculee ainsi etait strictement  */
                                        /* identique a 'v $xiird/AC1C.B1' alors qu'avec '$xci/substitue.04$I' l'image ainsi calculee */
                                        /* etait "binaire" (NOIR et BLANC) et ce a cause de '$xiii/di_image$FON iMOVE.evolution_a'   */
                                        /* situe a l'entree de la fonction 'Iautomate_cellulaire_monodimensionnel(...) ; je ne       */
                                        /* comprends toujours pas l'interet de faire appel a 'Nsubstitution(...)' a l'entree de      */
                                        /* cette fonction. Malgre tout 'v $Dhistory/lact14$D/20021007101007 20021005212727' montre   */
                                        /* que des tests ont ete fait dans ce sens. En conclusion ces "include"s semblent avoir ete  */
                                        /* inutiles avant cette date (mais pourquoi donc les avoir introduits le 20021005212108,     */
                                        /* soit trois jours seulement apres la creation de 'v $xci/AutoC_1DQ.01$K 20021002135359 ?). */
                                        /*                                                                                           */
                                        /* Malgre tout, le 20081206120905, j'ai introduit 'compatibilite_20081206' car, en effet,    */
                                        /* on ne sait jamais...                                                                      */

               EGAL(Iautomate_cellulaire_monodimensionnel_____num_liste_de_substitution,substitution_courante);
                                        /* Introduit le 20081205180232 en notant bien que je ne comprends pas a quoi servaient,      */
                                        /* avant cette date, l'ensemble des :                                                        */
                                        /*                                                                                           */
                                        /*                  #include  xci/substitue.0?.I"                                            */
                                        /*                                                                                           */
                                        /* (voir a ce propos les remarques du 20081206093712 ci-dessus).                             */
                                        /*                                                                                           */
                                        /* Donc a cette date, je les utilise pour acceder pleinement a la perturbation aleatoire     */
                                        /* des automates cellulaires ('v $xiii/di_image$FON 20081205162240')...                      */
               Eblock
          ATes
               Bblock
#include  xci/substitue.04.I"

               Test(IL_FAUT(perturber_aleatoirement))
                    Bblock
                    PRINT_ATTENTION("en mode 'compatibilite_20081206', l'automate cellulaire ne peut etre pertube aleatoirement");

                    EGAL(perturber_aleatoirement,FAUX);
                                        /* Dans le cas ou la compatibilite anterieure au 20081206120905 est demandee, la             */
                                        /* perturbation aleatoire de l'automate cellulaire est a priori desactivee...                */
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes
               Eblock
          ETes

          Test(IL_FAUT(perturber_aleatoirement))
               Bblock
               CALi(IFinitialisation(champ_de_perturbation_aleatoire,seuil_de_perturbation_aleatoire));
                                        /* A priori (et en particulier au cas ou il y aurait une erreur dans 'IloadF_image(...)').   */

               Test(IFNE_chaine(nom_imageP,NOM_UNDEF))
                                        /* On notera que lorsque 'nom_imageP' n'est pas specifie explicitement, c'est alors la       */
                                        /* valeur de 'seuil_de_perturbation_aleatoire' qui permet de proceder a l'initialisation     */
                                        /* de 'champ_de_perturbation_aleatoire'...                                                   */
                    Bblock
                    Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(champ_de_perturbation_aleatoire,nom_imageP))))
                         Bblock
                         Eblock
                    ATes
                         Bblock
                         Test__CODE_ERREUR__ERREUR07;
                         Eblock
                    ETes
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes
               Eblock
          ATes
               Bblock
               Eblock
          ETes

          PUSH_DIMENSIONS_3D;
          SET_DIMENSIONS_3D_SANS_VALIDATION(NIVR(NOIR),NIVR(BLANC)
                                           ,NIVR(NOIR),NIVR(BLANC)
                                           ,NIVR(NOIR),NIVR(BLANC)
                                            );
                                        /* L'automate cellulaire est une suite d'images de dimension COULEURSxCOULEURSxCOULEURS.     */

          begin_nouveau_block
               Bblock
               BDEFV(album,album_de_l_automate_cellulaire);
                                        /* Definition de l'album d'images contenant la definition de l'automate cellulaire.          */

               Test(IFNE_chaine(nom_imageC,NOM_UNDEF))
                    Bblock
                    CALi(dAload_album(album_de_l_automate_cellulaire
                                     ,nom_imageC
                                     ,nom_postfixe
                                     ,premiere_image
                                     ,pas_des_images
                                     ,nombre_de_chiffres
                                     ,FAUX
                                     ,UNDEF
                                     ,FAUX
                                      )
                         );
                                        /* Chargement de l'album Argument.                                                           */
                                        /*                                                                                           */
                                        /* L'argument 'Inv' (='FAUX') a ete introduit le 20091125132923...                           */

                    INITIALISATION_QUELCONQUE_AUTOMATE_CELLULAIRE_MONODIMENSIONNEL(automate_cellulaire
                                                                                  ,Aload_point_valide(album_de_l_automate_cellulaire
                                                                                                     ,COXA(NIVR(point_a_droite))
                                                                                                     ,COYA(NIVR(point_a_gauche))
                                                                                                     ,COZA(NIVR(point__courant))
                                                                                                      )
                                                                                   );
                                        /* Et initialisation de l'automate cellulaire...                                             */
                    Eblock
               ATes
                    Bblock
                    INITIALISATION_QUELCONQUE_AUTOMATE_CELLULAIRE_MONODIMENSIONNEL(automate_cellulaire
                                                                                  ,valeur_par_defaut_de_l_automate_cellulaire
                                                                                   );
                    Eblock
               ETes

               EDEFV(album,album_de_l_automate_cellulaire);
                                        /* Definition de l'album d'images contenant la definition de l'automate cellulaire.          */
               Eblock
          end_nouveau_block

          PULL_DIMENSIONS_3D;
                                        /* Restauration des dimensions de travail...                                                 */

          Test(IFOU(PAS_D_ERREUR(CODE_ERREUR)
                   ,IFET(IL_Y_A_ERREUR(CODE_ERREUR)
                        ,IL_FAUT(forcer_l_execution_en_cas_d_erreur_de_lecture_de_l_album_de_l_automate_cellulaire)
                         )
                    )
               )
                                        /* Le 'IL_FAUT(forcer_l_execution...)' a ete introduit le 20021004153954 dans le 'Test(...)' */
                                        /* afin de permettre l'utilisation d'albums incomplets, ce qui peut etre tres utile lorsque  */
                                        /* des automates binaires ({NOIR,BLANC} par exemple) sont utilises, puisqu'alors seules      */
                                        /* deux pages de l'album complet sont utiles...                                              */
               Bblock
               CALS(Iautomate_cellulaire_monodimensionnel(ImageR
                                                         ,ImageA
                                                         ,automate_cellulaire
                                                         ,Ymin_de_l_automate_cellulaire_monodimensionnel
                                                         ,Ymax_de_l_automate_cellulaire_monodimensionnel
                                                         ,perturber_aleatoirement
                                                         ,champ_de_perturbation_aleatoire
                                                          )
                    );
                                        /* Evolution de 'ImageA' suivant l'automate cellulaire 'automate_cellulaire'...              */
                                        /*                                                                                           */
                                        /* On rappelle qu'un automate cellulaire est une table de multiplication tridimensionnelle   */
                                        /* ou il est fait l'usage suivant des trois coordonnees :                                    */
                                        /*                                                                                           */
                                        /*                  point_a_gauche  --> Y                                                    */
                                        /*                  point__courant  --> Z                                                    */
                                        /*                  point_a_droite  --> X                                                    */
                                        /*                                                                                           */
                                        /* soit encore :                                                                             */
                                        /*                                                                                           */
                                        /*                  X               --> point_a_droite                                       */
                                        /*                  Y               --> point_a_gauche                                       */
                                        /*                  Z               --> point__courant                                       */
                                        /*                                                                                           */

               CALi(Iupdate_image(nom_imageR,ImageR));

#include  xci/substitue.06.I"
                                        /* Puis on desactive (introduit le 20081004191008...).                                       */
               Eblock
          ATes
               Bblock
               Eblock
          ETes
          Eblock
     ATes
          Bblock
          Test__CODE_ERREUR__ERREUR07;
          Eblock
     ETes

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.