/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   D E   L A   C O M P L E X I T E   S T R U C T U R E L L E                                                      */
/*        D E   " V R A I S "   P O I N T S   A L E A T O I R E S                                                                    */
/*        A D A P T E S   A   L A   C O M P L E X I T E   D E   K O L M O G O R O V  :                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/ObjetComplexe.G2$vv$c' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130607100849).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    COMMENTS
#         undef     COMMENTS
#else
#endif

#define   COMMENTS  "'Vrai' champ aleatoire type BBS (format bit) -noir ou blanc-"

#include  "images_1bit.01.vv.I"

long      int       ChaineBitsAleatoires[]={
#include  "ChaineBitsAleatoires_1024x1024.01.vv.I"
                                           };
                                        /* Le programme 'v $xrC/ObjetComplexe.G2$vv$c' est adapte a la mesure de la Complexite       */
                                        /* Algorithmique de Kolmogorov puisque chaque bit de la chaine de bits aleatoires n'occupe   */
                                        /* qu'un seul bit de memoire. Sa longueur mesurees en bits a partir du binaire non           */
                                        /* executable ('v $xrC/Mesures.01$vv$Z .CoMpIlE..-c') est alors egale (en bits) au nombre    */
                                        /* de bits de la chaine aleatoire plus une petite constante (voir a ce propos                */
                                        /* 'v $xrC/ObjetComplexe.F2$vv$c 20130519121302' pour avoir des informations concernant      */
                                        /* la longueur du binaire non executable).                                                   */
                                        /*                                                                                           */
                                        /* Les programmes 'v $xrC/ObjetComplexe.L1$vv$c' et 'v $xrC/ObjetComplexe.L2$vv$c' sont      */
                                        /* eux adaptes a la mesure de la Complexite Structuelle de Bennet puisque l'on mesure        */
                                        /* alors le nombre d'instructions necessaires au transfert de la chaine de bits aleatoires   */
                                        /* dans une matrice de bits (la conversion bit -- > octet etant penalisante...).              */
                                        /*                                                                                           */
                                        /* Les programmes 'v $xrC/ObjetComplexe.M1$vv$c' et 'v $xrC/ObjetComplexe.M2$vv$c' sont      */
                                        /* eux aussi adaptes a la mesure de la Complexite Structuelle de Bennet puisque l'on mesure  */
                                        /* alors le nombre d'instructions necessaires au transfert de la chaine de bits aleatoires   */
                                        /* (representees par une chaine d'octets : un bit est contenu dans un octet) dans une        */
                                        /* matrice d'octets (ce qui est donc plus rapide que ci-dessus...).                          */

MAIN(
          {

#ifndef   NE_PAS_SORTIR_LE_FICHIER_IMAGE

#         ifdef     CONVERTIR_LE_FICHIER_IMAGE
                    {
                    TypeImage image_convertie[dimY][dimX];

                    CONVOLUTION_IMAGE;
                    TRANSFORMATION_IMAGE;
                                        /* Les transformations ont ete introduites le 20140125093812...                              */ \

                    for       (y=Ymin ; y <= Ymax ; y=ADD2(y,1))
                              {
                              for       (x=Xmin ; x <= Xmax ; x=ADD2(x,1))
                                        {
                                        int       xQ=DIVI(x,NOMBRE_DE_BITS_PAR_MOT);
                                        int       xR=REST(x,NOMBRE_DE_BITS_PAR_MOT);

                                        image_convertie[y][x]=COND(((ChaineBitsAleatoires[xQ+(y*(dimX/NOMBRE_DE_BITS_PAR_MOT))] & DECG((long int)BIT,xR))==0),NOIR,BLANC);
                                        /* ATTENTION, il est evidemment impossible d'utiliser :                                      */
                                        /*                                                                                           */
                                        /*                  gSTORE_IMAGE_PLAN(image_convertie,x,COND(...));                          */
                                        /*                                                                                           */
                                        }
                              }

                    write(STDOUT,image_convertie,GDimImages);
                    }
#         else
                    write(STDOUT,ChaineBitsAleatoires,DimImages);
#         endif

#else
#endif

          EDITER_LES_COMPTEURS_DES_FONCTIONS;
          }
     )