/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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 ' U N   R E S E A U   A L E A T O I R E   D E   S E G M E N T S   H O R I Z O N T A U X   O U   V E R T I C A U X  :     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/ObjetComplexe.51$vv$c' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130504110154).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    COMMENTS
#         undef     COMMENTS
#else
#endif

#define   COMMENTS  "Reseau de segments aleatoires horizontaux ou verticaux (format octet) -noir ou blanc-"

#define   DEFINE_01 "-DNOMBRE_X=gDIVI(dimX,105) -DNOMBRE_Y=gDIVI(dimY,105)"
#define   DEFINE_02 "-DNOMBRE_X=gDIVI(dimX,98)  -DNOMBRE_Y=gDIVI(dimY,98)"
#define   DEFINE_03 "-DNOMBRE_X=gDIVI(dimX,91)  -DNOMBRE_Y=gDIVI(dimY,91)"
#define   DEFINE_04 "-DNOMBRE_X=gDIVI(dimX,84)  -DNOMBRE_Y=gDIVI(dimY,84)"
#define   DEFINE_05 "-DNOMBRE_X=gDIVI(dimX,77)  -DNOMBRE_Y=gDIVI(dimY,77)"
#define   DEFINE_06 "-DNOMBRE_X=gDIVI(dimX,70)  -DNOMBRE_Y=gDIVI(dimY,70)"
#define   DEFINE_07 "-DNOMBRE_X=gDIVI(dimX,63)  -DNOMBRE_Y=gDIVI(dimY,63)"
#define   DEFINE_08 "-DNOMBRE_X=gDIVI(dimX,56)  -DNOMBRE_Y=gDIVI(dimY,56)"
#define   DEFINE_09 "-DNOMBRE_X=gDIVI(dimX,49)  -DNOMBRE_Y=gDIVI(dimY,49)"
#define   DEFINE_10 "-DNOMBRE_X=gDIVI(dimX,42)  -DNOMBRE_Y=gDIVI(dimY,42)"
#define   DEFINE_11 "-DNOMBRE_X=gDIVI(dimX,35)  -DNOMBRE_Y=gDIVI(dimY,35)"
#define   DEFINE_12 "-DNOMBRE_X=gDIVI(dimX,28)  -DNOMBRE_Y=gDIVI(dimY,28)"
#define   DEFINE_13 "-DNOMBRE_X=gDIVI(dimX,21)  -DNOMBRE_Y=gDIVI(dimY,21)"
#define   DEFINE_14 "-DNOMBRE_X=gDIVI(dimX,14)  -DNOMBRE_Y=gDIVI(dimY,14)"
#define   DEFINE_15 "-DNOMBRE_X=gDIVI(dimX,7)   -DNOMBRE_Y=gDIVI(dimY,7)"
#define   DEFINE_16 "-DNOMBRE_X=gDIVI(dimX,1)   -DNOMBRE_Y=gDIVI(dimY,1)"
                                        /* Les diviseurs des dimensions ont ete obtenus par :                                        */
                                        /*                                                                                           */
                                        /*                  $xci/valeurs_inte$X                                                   \  */
                                        /*                                      p=1 d=16                                          \  */
                                        /*                                      lineaire=VRAI                                     \  */
                                        /*                                      vD=1 vA=105                                       \  */
                                        /*                                      entiers=VRAI                                         */
                                        /*                                                                                           */

#include  "images_1octet.01.vv.I"

#include  "Flogarithme2.01.vv.I"

long      int       m;
long      int       seuil;
long      int       a=0x5DEECE66D;
long      int       c=0xB;
long      int       d=48-32;
long      int       Xi=1;

int       FonctionPrivee_aleatoire(masque,dimension)
int       masque;
int       dimension;
          {
          Xi = REST(ADD2(MUL2(a,Xi),c),m);
          return(REST((int)ETLO(DECD(Xi,d),((long int)masque)),dimension));
          }

#ifndef   NOMBRE_X
#         define    NOMBRE_X                                                                                                            \
                              gDIVI(dimX,5)
#else
#endif

#ifndef   NOMBRE_Y
#         define    NOMBRE_Y                                                                                                            \
                              gDIVI(dimY,5)
#else
#endif

int       nombre_X=NOMBRE_X;
int       nombre_Y=NOMBRE_Y;

MAIN(
          {
          int                 masqueX=SOUS(DECG(BIT,(int)ADD2(Flogarithme2(dimX),1)),1);
          int                 masqueY=SOUS(DECG(BIT,(int)ADD2(Flogarithme2(dimY),1)),1);
          int                 iterationX;
          int                 iterationY;

          m=MUL2(4096,4096);
          m=MUL2(m,m);
          seuil=DIVI(m,2);
                                        /* Les valeurs des parametres {m,seuil,a,c} sont ceux de la fonction 'drand48(...)'.         */

          INITIALISATION_IMAGE(NOIR);

          for       (iterationX=1 ; iterationX <= nombre_X ; iterationX=ADD2(iterationX,1))
                    {
                    int       x;
                    int       y=ADD2(FonctionPrivee_aleatoire(masqueY,dimY),Ymin);
                    int       x1=ADD2(FonctionPrivee_aleatoire(masqueX,dimX),Xmin);
                    int       x2=ADD2(FonctionPrivee_aleatoire(masqueX,dimX),Xmin);
                    if        (x1 > x2)
                              {
                              int       x3=x2;
                              x2=x1;
                              x1=x3;
                              }
                    else
                              {
                              }

                    for       (x=x1 ; x <= x2 ; x=ADD2(x,1))
                              {
                              STORE_IMAGE_TORE(x,y,BLANC);
                              }
                    }

          for       (iterationY=1 ; iterationY <= nombre_Y ; iterationY=ADD2(iterationY,1))
                    {
                    int       x=ADD2(FonctionPrivee_aleatoire(masqueX,dimX),Xmin);
                    int       y;
                    int       y1=ADD2(FonctionPrivee_aleatoire(masqueY,dimY),Ymin);
                    int       y2=ADD2(FonctionPrivee_aleatoire(masqueY,dimY),Ymin);
                    if        (y1 > y2)
                              {
                              int       y3=y2;
                              y2=y1;
                              y1=y3;
                              }
                    else
                              {
                              }

                    for       (y=y1 ; y <= y2 ; y=ADD2(y,1))
                              {
                              STORE_IMAGE_TORE(x,y,BLANC);
                              }
                    }

          SORTIE_DU_FICHIER_IMAGE;
          EDITER_LES_COMPTEURS_DES_FONCTIONS;
          }
     )