/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   O P E R A T I O N S   D ' A C C E S  :                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xci/acces.01$I' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20001224094035).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   DETRUIRE_L_IMAGE                                                                                                              \
                    FAUX                                                                                                                \
                                        /* Faut-il uniquement detruire l'image ?                                                     */

#define   IL_FAUT_CONVERTIR_LES_IMAGES_STANDARDS                                                                                        \
                    FAUX                                                                                                                \
                                        /* Faut-il convertir les images 'Standard's en flottant ?                                    */
#define   IL_FAUT_NORMALISER_APRES_CONVERSION_LES_IMAGES_STANDARDS                                                                      \
                    FAUX                                                                                                                \
                                        /* Lorsqu'il faut convertir les images 'Standard's en flottant, faut-il normaliser ('VRAI')  */ \
                                        /* ou pas ('FAUX'). Ceci fut introduit le 20090318141357...                                  */
#define   IL_FAUT_INTERPOLER_APRES_CONVERSION_LES_IMAGES_STANDARDS                                                                      \
                    FAUX                                                                                                                \
                                        /* Lorsqu'il faut convertir les images 'Standard's en flottant, faut-il interpoler ('VRAI')  */ \
                                        /* ou pas ('FAUX').                                                                          */
#define   IL_FAUT_INTERPOLER_LINEAIREMENT                                                                                               \
                    FAUX                                                                                                                \
                                        /* L'interpolation doit-elle etre alors lineaire ('VRAI') ou cubique ('FAUX').               */

#define   IL_FAUT_CONVERTIR_LES_IMAGES_NON_STANDARDS                                                                                    \
                    VRAI                                                                                                                \
                                        /* Faut-il convertir les images non 'Standard's en images 'Standard's ? Ceci a ete           */ \
                                        /* introduit le 20030502150244 et la valeur par defaut est choisie de facon a assurer        */ \
                                        /* la compatibilite anterieure...                                                            */

#include  xci/acces.11.I"
                                        /* Introduit le 20050120121007 pour definir 'CONSERVER_LE_ZERO' afin que cette definition    */
                                        /* soit disponible pour 'v $xrs/surfaces.14$I CONSERVER_LE_ZERO'...                          */

#TestADef IL_FAUT_RENORMALISER                                                                                                          \
                    FAUX                                                                                                                \
                                        /* Faut-il renormaliser l'image ?                                                            */ \
                                        /*                                                                                           */ \
                                        /* Le 20070712100752 le "#define" est devenu un "#TestADef" pour plus de generalite...       */

#define   CONVERTIR_BRUTALEMENT                                                                                                         \
                    FAUX                                                                                                                \
                                        /* Afin de pouvoir convertir les images flottantes sans tester la validite de leurs          */ \
                                        /* niveaux par rapport aux capacites des images 'Standard's. Cette possibilite fut           */ \
                                        /* introduite le 20080902110924 afin de permettre des chaines de conversion du type :        */ \
                                        /*                                                                                           */ \
                                        /*                  Standard --> Float --> Standard                                          */ \
                                        /*                                                                                           */ \
                                        /* telles que les niveaux des images 'Standard's de Depart et d'Arrivee soient "homogenes"   */ \
                                        /* (en particulier identiques -aux arrondis pres- dans le cas d'une chaines de conversion    */ \
                                        /* sans autres transformations...). Ainsi, par exemple :                                     */ \
                                        /*                                                                                           */ \
                                        /*                  $xci/acces$X                                                          \  */ \
                                        /*                                      A=IMAGE1                                          \  */ \
                                        /*                                      convertir=VRAI                                    \  */ \
                                        /*                                                                    $formatI       |    \  */ \
                                        /*                  $xci/acces$X                                                          \  */ \
                                        /*                                      standard=FAUX brutal=VRAI                         \  */ \
                                        /*                                      R=IMAGE2                                          \  */ \
                                        /*                                                                    $formatI               */ \
                                        /*                                                                                           */ \
                                        /* donnera 'IMAGE2' identique a 'IMAGE1' et ce quel que soient les extrema de cette derniere */ \
                                        /* image...                                                                                  */

#define   IL_FAUT_CALCULER_LES_EXTREMA_DES_IMAGES_NON_STANDARDS                                                                         \
                    VRAI                                                                                                                \
                                        /* Dans le cas d'une image flottante faut-il calculer les extrema pour la conversion         */ \
                                        /* ('VRAI') ou les forcer ('FAUX') ?                                                         */
#define   TRONQUER_LES_NIVEAUX                                                                                                          \
                    FAUX                                                                                                                \
                                        /* Lorsque 'EST_FAUX(il_faut_calculer_les_extrema_des_images_non_standards)', faut-il        */ \
                                        /* ou pas tronquer les niveaux.                                                              */
#define   MINIMUM_FORCE                                                                                                                 \
                    FLOT__NOIR
#define   MAXIMUM_FORCE                                                                                                                 \
                    FLOT__BLANC
                                        /* Valeur forcee des extrema d'une image flottante lorsque les extrema ne sont pas a         */
                                        /* calculer ou lorsque des images 'Standard's sont a convertir en flottant...                */

#define   L_IMAGE_NON_STANDARD_EST_UN_Z_Buffer                                                                                          \
                    FAUX                                                                                                                \
                                        /* Dans le cas d'une image flottante, est-ce un 'Z-Buffer' (introduit le 20050418094817) ?   */

#define   NIVEAU_DE_NOIR_REMONTE                                                                                                        \
                    NOIR                                                                                                                \
                                        /* Niveau de NOIR de l'image Resultat.                                                       */