/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D O N N E E S   C O M M U N E S   D ' I M A G E S   D E   T Y P E   ' bit '   P O U R                                      */
/*        L ' 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  :                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/images_1bit.01$vv$I' :                                                                                     */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130509211406).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#define   TYPE_BIT__
                                        /* Introduit le 20130730102154...                                                            */

#define   dimXb                                                                                                                         \
                    (dimX/NBITOC)

#define   IMAGE_TEMPORAIRE_1                                                                                                            \
                    TypeImage DEFINITION_IMAGE(imageT1,dimY,dimXb)                                                                      \
                                        /* Introduit le 20140113143947...                                                            */

#define   DimImages                                                                                                                     \
                    gMUL2(dimXb,dimY)                                                                                                   \
                                        /* Dimension introduit le 20140116110650...                                                  */

#include  "images.01.vv.I"

TypeImage DEFINITION_IMAGE(image,dimY,dimXb);

#ifndef   SEUIL_DE_BINARISATION
#         define    SEUIL_DE_BINARISATION                                                                                               \
                              GRIS                                                                                                      \
                                        /* Introduit le 20130729114018...                                                            */
#else
#endif

#         define    gLOAD_IMAGE_PLAN(image,x,y)                                                                                         \
                              ETLO(DECD(INDEXATION_IMAGE(image,y,DIVI(x,NBITOC)),REST(x,NBITOC)),BIT)
#         define    gLOAD_IMAGE_TORE(image,x,y)                                                                                         \
                              gLOAD_IMAGE_PLAN(image                                                                                    \
                                              ,ADD2(REST(ADD2(REST(SOUS(x,Xmin),dimX),dimX),dimX),Xmin)                                 \
                                              ,ADD2(REST(ADD2(REST(SOUS(y,Ymin),dimY),dimY),dimY),Ymin)                                 \
                                               )
                                        /* Definitions introduites le 20130730092739...                                              */

#         define    gLOAD_IMAGE_PLAN_BIT_OCTET(image,x,y)                                                                               \
                              MUL2(gLOAD_IMAGE_PLAN(image,x,y),COULEURS)
#         define    gLOAD_IMAGE_TORE_BIT_OCTET(image,x,y)                                                                               \
                              MUL2(gLOAD_IMAGE_TORE(image,x,y),COULEURS)
                                        /* Definitions introduites le 20130730104422 pour le traitement des images reelles a         */
                                        /* convertir de "octet" a "bit"...                                                           */

#         define    LOAD_IMAGE_PLAN(x,y)                                                                                                \
                              gLOAD_IMAGE_PLAN(image,x,y)
#         define    LOAD_IMAGE_TORE(x,y)                                                                                                \
                              gLOAD_IMAGE_TORE(image,x,y)
                                        /* Definitions introduites le 20130730092739...                                              */

#         define    LOAD_IMAGE_PLAN_BIT_OCTET(x,y)                                                                                      \
                              gLOAD_IMAGE_PLAN_BIT_OCTET(image,x,y)
#         define    LOAD_IMAGE_TORE_BIT_OCTET(x,y)                                                                                      \
                              gLOAD_IMAGE_TORE_BIT_OCTET(image,x,y)
                                        /* Definitions introduites le 20130730103050 pour le traitement des images reelles a         */
                                        /* convertir de "octet" a "bit"...                                                           */

#define   gSTORE_IMAGE_PLAN(image,x,y,niveau)                                                                                           \
                    {                                                                                                                   \
                    int       xQ=DIVI(x,NBITOC);                                                                                        \
                    int       xR=REST(x,NBITOC);                                                                                        \
                                                                                                                                        \
                    INDEXATION_IMAGE(image,y,xQ) = ETLO(INDEXATION_IMAGE(image,y,xQ),OUEX(BLANC,DECG(BIT,xR)));                         \
                                        /* Mise a 0 du bit courant {x,y}.                                                            */ \
                                                                                                                                        \
                    if        (niveau >= SEUIL_DE_BINARISATION)                                                                         \
                                        /* Le 20130729111616 le test :                                                               */ \
                                        /*                                                                                           */ \
                                        /*                  if        (niveau != NOIR)                                               */ \
                                        /*                                                                                           */ \
                                        /* afin de permettre d'etendre la portee des images "format bit", en particulier avec        */ \
                                        /* 'v $xrC/ObjetComplexe.S____2$vv$c'...                                                     */ \
                              {                                                                                                         \
                              INDEXATION_IMAGE(image,y,xQ) = OUIN(INDEXATION_IMAGE(image,y,xQ),DECG(BIT,xR));                           \
                                        /* Mise a 1 du bit courant {x,y}.                                                            */ \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }
#define   gSTORE_IMAGE_TORE(image,x,y,niveau)                                                                                           \
                    {                                                                                                                   \
                    int       Xtore=ADD2(REST(ADD2(REST(SOUS(x,Xmin),dimX),dimX),dimX),Xmin);                                           \
                    int       Ytore=ADD2(REST(ADD2(REST(SOUS(y,Ymin),dimY),dimY),dimY),Ymin);                                           \
                                                                                                                                        \
                    gSTORE_IMAGE_PLAN(image,Xtore,Ytore,niveau);                                                                        \
                    }

#define   STORE_IMAGE_PLAN(x,y,niveau)                                                                                                  \
                    {                                                                                                                   \
                    gSTORE_IMAGE_PLAN(image,x,y,niveau);                                                                                \
                    }
#define   STORE_IMAGE_TORE(x,y,niveau)                                                                                                  \
                    {                                                                                                                   \
                    gSTORE_IMAGE_TORE(image,x,y,niveau);                                                                                \
                    }

#define   ACCES_IMAGE_REELLE(nom_de_l_image_reelle)                                                                                     \
                                        /* On notera que 'image_reelle' ne peut etre un argument ci-dessus a cause de l'usage de     */ \
                                        /* cette procedure 'ACCES_IMAGE_REELLE(...)' dans 'MAIN(...)' qui n'autorise pas la          */ \
                                        /* presence de virgules a l'interieur de son argument...                                     */ \
                    {                                                                                                                   \
                    TypeImage DEFINITION_IMAGE(image_reelle,dimY,dimX);                                                                 \
                                                                                                                                        \
                    FILE      *Fdescripteur;                                                                                            \
                                                                                                                                        \
                    Fdescripteur = fopen(nom_de_l_image_reelle,"r");                                                                    \
                    fread(image_reelle,1,GDimImages,Fdescripteur);                                                                      \
                                        /* Il faut evidemment lire le fichier 'octet' entier, d'ou le 'GDimImages'...                */ \
                                                                                                                                        \
                    INITIALISATION_IMAGE(INDEXATION_IMAGE(image_reelle,y,x));                                                           \
                    }                                                                                                                   \
                                        /* Procedure introduite le 20130729211816...                                                 */
#define   ACCES_IMAGE_SYNTHETIQUE(nom_de_l_image_synthetique)                                                                           \
                    {                                                                                                                   \
                    ACCES_IMAGE_REELLE(nom_de_l_image_synthetique);                                                                     \
                    }                                                                                                                   \
                                        /* Procedure introduite le 20150128100235...                                                 */

#ifdef    NE_PAS_SORTIR_LE_FICHIER_IMAGE
#         define    SORTIE_DU_FICHIER_IMAGE                                                                                             \
                              {                                                                                                         \
                              }
#else

#         ifdef     CONVERTIR_LE_FICHIER_IMAGE
#                   define    SORTIE_DU_FICHIER_IMAGE                                                                                   \
                                        {                                                                                               \
                                        TypeImage DEFINITION_IMAGE(image_convertie,dimY,dimX);                                          \
                                                                                                                                        \
                                        CONVOLUTION_IMAGE;                                                                              \
                                        TRANSFORMATION_IMAGE;                                                                           \
                                        /* Les transformations ont ete introduites le 20140113114553...                              */ \
                                                                                                                                        \
                                        for       (y=Ymin ; y <= Ymax ; y=ADD2(y,1))                                                    \
                                                  {                                                                                     \
                                                  for       (x=Xmin ; x <= Xmax ; x=ADD2(x,1))                                          \
                                                            {                                                                           \
                                                            int       xQ=DIVI(x,NBITOC);                                                \
                                                            int       xR=REST(x,NBITOC);                                                \
                                                                                                                                        \
                                                            gINDEXATION_IMAGE(image_convertie,y,x,dimX)                                 \
                                                            =COND(((INDEXATION_IMAGE(image,y,xQ) & DECG(BIT,xR))==0),NOIR,BLANC);       \
                                                            }                                                                           \
                                                  }                                                                                     \
                                                                                                                                        \
                                        write(STDOUT,image_convertie,GDimImages);                                                       \
                                        }
#         else
#                   define    SORTIE_DU_FICHIER_IMAGE                                                                                   \
                                        {                                                                                               \
                                        CONVOLUTION_IMAGE;                                                                              \
                                        TRANSFORMATION_IMAGE;                                                                           \
                                        /* Les transformations ont ete introduites le 20140113114553...                              */ \
                                                                                                                                        \
                                        write(STDOUT,image,DimImages);                                                                  \
                                        }
#         endif
#endif