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

#ifdef    COMMENTS
#         undef     COMMENTS
#else
#endif

#define   COMMENTS  "Croix fractale mixee avec des points pseudo-aleatoires type 'drand48(...)' (format octet) -noir ou blanc-"

#define   DEFINE_01 "-DLIMITE_X=gMUL2(0,gDIVI(dimX,15))"
#define   DEFINE_02 "-DLIMITE_X=gMUL2(2,gDIVI(dimX,15))"
#define   DEFINE_03 "-DLIMITE_X=gMUL2(2,gDIVI(dimX,15))"
#define   DEFINE_04 "-DLIMITE_X=gMUL2(3,gDIVI(dimX,15))"
#define   DEFINE_05 "-DLIMITE_X=gMUL2(4,gDIVI(dimX,15))"
#define   DEFINE_06 "-DLIMITE_X=gMUL2(5,gDIVI(dimX,15))"
#define   DEFINE_07 "-DLIMITE_X=gMUL2(6,gDIVI(dimX,15))"
#define   DEFINE_08 "-DLIMITE_X=gMUL2(7,gDIVI(dimX,15))"
#define   DEFINE_09 "-DLIMITE_X=gMUL2(8,gDIVI(dimX,15))"
#define   DEFINE_10 "-DLIMITE_X=gMUL2(9,gDIVI(dimX,15))"
#define   DEFINE_11 "-DLIMITE_X=gMUL2(10,gDIVI(dimX,15))"
#define   DEFINE_12 "-DLIMITE_X=gMUL2(11,gDIVI(dimX,15))"
#define   DEFINE_13 "-DLIMITE_X=gMUL2(12,gDIVI(dimX,15))"
#define   DEFINE_14 "-DLIMITE_X=gMUL2(13,gDIVI(dimX,15))"
#define   DEFINE_15 "-DLIMITE_X=gMUL2(14,gDIVI(dimX,15))"
#define   DEFINE_16 "-DLIMITE_X=gMUL2(15,gDIVI(dimX,15))"

#include  "images_1octet.01.vv.I"

#include  "Flogarithme2.01.vv.I"

#define   FACTEUR_1                                                                                                                     \
                    (2)
#define   FACTEUR_2                                                                                                                     \
                    (4)

int       facteur_1=FACTEUR_1;
int       facteur_2=FACTEUR_2;

#ifndef   SEUIL
#         define    SEUIL                                                                                                               \
                              (0.5)
#else
#endif

double    seuil=SEUIL;

#ifndef   LIMITE_X
#         define    LIMITE_X                                                                                                            \
                              gDIVI(dimX,2)
#else
#endif

double    limite_X=LIMITE_X;

#define   MARQUAGE_POINT_CROIX                                                                                                          \
                    {                                                                                                                   \
                    if        (xk < limite_X)                                                                                           \
                              {                                                                                                         \
                              STORE_IMAGE_TORE(xk,yk,BLANC);                                                                            \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }

FonctionPrivee_croix(Xc,Yc,dX,dY,iterations)
int       Xc,Yc;
int       dX,dY;
int       iterations;
          {
          if        (iterations > 0)
                    {
                    int       xk,yk;
                    xk=SOUS(Xc,dX);
                    yk=Yc;
                    FonctionPrivee_croix(xk,yk,DIVI(dX,facteur_1),DIVI(dY,facteur_1),SOUS(iterations,1));

                    for       (xk=xk ; xk <= ADD2(Xc,dX) ; xk=ADD2(xk,1))
                              {
                              MARQUAGE_POINT_CROIX;
                              }

                    FonctionPrivee_croix(SOUS(xk,1),yk,DIVI(dX,facteur_1),DIVI(dY,facteur_1),SOUS(iterations,1));
                                        /* Le 'SOUS(xk,1)' vient du fait qu'a la sortie du 'for(...)' precedent, la coordonnee 'xk'  */
                                        /* vaut son maximum ('ADD2(Xc,dX)') plus un : il faut donc revenir d'un cran en arriere...   */

                    xk=Xc;
                    yk=SOUS(Yc,dY);
                    FonctionPrivee_croix(xk,yk,DIVI(dX,facteur_1),DIVI(dY,facteur_1),SOUS(iterations,1));

                    for       (yk=yk ; yk <= ADD2(Yc,dY) ; yk=ADD2(yk,1))
                              {
                              MARQUAGE_POINT_CROIX;
                              }

                    FonctionPrivee_croix(xk,SOUS(yk,1),DIVI(dX,facteur_1),DIVI(dY,facteur_1),SOUS(iterations,1));
                                        /* Le 'SOUS(yk,1)' vient du fait qu'a la sortie du 'for(...)' precedent, la coordonnee 'yk'  */
                                        /* vaut son maximum ('ADD2(Yc,dY)') plus un : il faut donc revenir d'un cran en arriere...   */
                    }
          else
                    {
                    }

          return(OK);
          }

MAIN(
          {
          long      int       m=0x0000ffffffffffff;
          long      int       a=0x5DEECE66D;
          long      int       c=0xB;
          long      int       Xi=1;
                                        /* Les valeurs des parametres {m,a,c} sont ceux de la fonction 'drand48(...)'.               */

          int       iterations=SOUS((int)Flogarithme2(MIN2(dimX,dimY)),2);
          int       demi_longueur_X=DIVI(dimX,facteur_2);
          int       demi_longueur_Y=DIVI(dimY,facteur_2);

          INITIALISATION_IMAGE(NOIR);

          for       (y=Ymin ; y <= Ymax ; y=ADD2(y,1))
                    {
                    for       (x=Xmin ; x <= Xmax ; x=ADD2(x,1))
                              {
                              if        (x >= limite_X)
                                        {
                                        Xi = ETLO(ADD2(MUL2(a,Xi),c),m);

                                        STORE_IMAGE_PLAN(x,y,COND(IFLT(DIVIf(((double)Xi),((double)m)),seuil),NOIR,BLANC));
                                        }
                              else
                                        {
                                        }
                              }
                    }

          FonctionPrivee_croix(ADD2(Xmin,dimXs2),ADD2(Ymin,dimYs2),demi_longueur_X,demi_longueur_Y,iterations);

          SORTIE_DU_FICHIER_IMAGE;
          EDITER_LES_COMPTEURS_DES_FONCTIONS;
          }
     )