/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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.03$I' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20001224094035).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V A R I A B L E S   U T I L E S  :                                                                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
     DEFV(Logical,INIT(detruire_l_image,DETRUIRE_L_IMAGE));
                                        /* Faut-il uniquement detruire l'image ?                                                     */
     DEFV(Logical,INIT(il_faut_convertir_les_images_standards,IL_FAUT_CONVERTIR_LES_IMAGES_STANDARDS));
                                        /* Faut-il convertir les images 'Standard's en flottant ?                                    */
     DEFV(Logical,INIT(il_faut_normaliser_apres_conversion_les_images_standards
                      ,IL_FAUT_NORMALISER_APRES_CONVERSION_LES_IMAGES_STANDARDS
                       )
          );
                                        /* Lorsqu'il faut convertir les images 'Standard's en flottant, faut-il normaliser ('VRAI')  */
                                        /* ou pas ('FAUX'). Ceci fut introduit le 20090318141500...                                  */
     DEFV(Logical,INIT(il_faut_interpoler_apres_conversion_les_images_standards
                      ,IL_FAUT_INTERPOLER_APRES_CONVERSION_LES_IMAGES_STANDARDS
                       )
          );
                                        /* Lorsqu'il faut convertir les images 'Standard's en flottant, faut-il interpoler ('VRAI')  */
                                        /* ou pas ('FAUX').                                                                          */
     DEFV(Logical,INIT(il_faut_interpoler_lineairement,IL_FAUT_INTERPOLER_LINEAIREMENT));
                                        /* L'interpolation doit-elle etre alors lineaire ('VRAI') ou cubique ('FAUX').               */
     DEFV(Logical,INIT(il_faut_convertir_les_images_non_standards,IL_FAUT_CONVERTIR_LES_IMAGES_NON_STANDARDS));
                                        /* 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...                                                            */
     DEFV(Logical,INIT(conserver_le_zero,CONSERVER_LE_ZERO));
                                        /* En cas d'image 'imageF' doit-on conserver le zero ('VRAI') ou pas ('FAUX').               */
     DEFV(Logical,INIT(il_faut_calculer_les_extrema_des_images_non_standards,IL_FAUT_CALCULER_LES_EXTREMA_DES_IMAGES_NON_STANDARDS));
                                        /* Dans le cas d'une image flottante faut-il calculer les extrema pour la conversion         */
                                        /* ('VRAI') ou les forcer ('FAUX') ?                                                         */
     DEFV(Logical,INIT(convertir_brutalement,CONVERTIR_BRUTALEMENT));
                                        /* 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...                                                                                  */
     DEFV(Logical,INIT(tronquer_les_niveaux,TRONQUER_LES_NIVEAUX));
                                        /* Lorsque 'EST_FAUX(il_faut_calculer_les_extrema_des_images_non_standards)', faut-il        */
                                        /* ou pas tronquer les niveaux.                                                              */
     DEFV(genere_Float,INIT(minimum_force,MINIMUM_FORCE));
     DEFV(genere_Float,INIT(maximum_force,MAXIMUM_FORCE));
                                        /* Valeurs a forcer pour les extrema d'une image flottante lorsque les extrema ne sont pas   */
                                        /* a calculer ou lorsque des images 'Standard's sont a convertir en flottant...              */
     DEFV(Logical,INIT(l_image_non_standard_est_un_Z_Buffer,L_IMAGE_NON_STANDARD_EST_UN_Z_Buffer));
                                        /* Dans le cas d'une image flottante, est-ce un 'Z-Buffer' (introduit le 20050418095035) ?   */
     DEFV(genere_p,INIT(niveau_de_NOIR_remonte,NIVEAU_DE_NOIR_REMONTE));
                                        /* Niveau de NOIR de l'image Resultat.                                                       */