/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A C C U M U L A T I O N   D ' U N E   S E R I E   D ' I M A G E S                                                          */
/*        E N   F O N C T I O N   D E   L A   T R O I S I E M E   D I M E N S I O N  :                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Cette commande "accumule" une serie d'images                                                                   */
/*                  en effectuant l'operation suivante ('i' designant                                                                */
/*                  un indice de parcours de la liste 'Image') :                                                                     */
/*                                                                                                                                   */
/*                                      Cumul <-- Cumul + Image(i) en fonction du 'Z-Buffer'                                         */
/*                                                                                                                                   */
/*                  avec implicitement un parcours d'arriere en avant (c'est-a-dire                                                  */
/*                  que la premiere image recuperee est mise en arriere-plan et la                                                   */
/*                  derniere au premier-plan), cet ordre pouvant etre inverse.                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xci/accumule.22$K' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 19990609094902).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N T E R F A C E   ' listG '  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        :Debut_listG:                                                                                                              */
/*        :Fin_listG:                                                                                                                */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I R E C T I V E S   S P E C I F I Q U E S   D E   C O M P I L A T I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_BASE
#include  image_image_IMAGESF_EXT

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/sequence.01.I"

#define   INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES                                                                                   \
                    FAUX                                                                                                                \
                                        /* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a :           */ \
                                        /*                                                                                           */ \
                                        /*                  FAUX    : l'image d'arriere-plan est la premiere de la liste,            */ \
                                        /*                  VRAI    : l'image d'arriere-plan est la derniere de la liste.            */ \
                                        /*                                                                                           */

#include  xci/accumule.01.I"

#define   MEMORISER_LE_Z_BUFFER                                                                                                         \
                    FAUX                                                                                                                \
                                        /* Indique si le 'Z-Buffer' doit etre fourni comme resultat ('VRAI'), ou bien oublie         */ \
                                        /* apres le calcul ('FAUX'). On notera que la sortie du 'Z-Buffer' peut etre redondante      */ \
                                        /* d'avec celle de l'accumulation proprement dite, mais que cela n'est plus vrai des que     */ \
                                        /* 'IL_NE_FAUT_PAS(binariser_les_images)'.                                                   */
#define   MEMORISER_LE_Z_BUFFER_COMME_UNE_IMAGE_STANDARD                                                                                \
                    VRAI                                                                                                                \
                                        /* Indique si le 'Z-Buffer' est fourni comme resultat, si ce dernier doit etre fourni en     */ \
                                        /* tant qu'image standard ('VRAI') ou pas ('FAUX').                                          */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/accumule.02.I"
#include  xci/accumule.04.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A C C U M U L A T I O N   D ' U N E   S E R I E   D ' I M A G E S                                                          */
/*        E N   F O N C T I O N   D E   L A   T R O I S I E M E   D I M E N S I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
                                        /* Nom de la sequence a integrer.                                                            */
     DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
                                        /* Nom d'un eventuel postfixe a placer derriere <nom_imageA><numero> (par exemple '$ROUGE'). */
     DEFV(CHAR,INIC(POINTERc(nom_imageAZ),NOM_PIPE));
                                        /* Nom de la sequence 'Z-Buffer' Argument.                                                   */
     DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
                                        /* Nom du Resultat de l'integration.                                                         */
     DEFV(CHAR,INIC(POINTERc(nom_imageRZ),NOM_PIPE));
                                        /* Nom de l'eventuel 'Z-Buffer' Resultat.                                                    */
     DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
                                        /* Numero de la premiere image,                                                              */
     DEFV(Int,INIT(derniere_image,DERNIERE_IMAGE));
                                        /* Numero de la derniere image.                                                              */
     DEFV(Int,INIT(translation_des_numeros_des_images,TRANSLATION_DES_NUMEROS_DES_IMAGES));
                                        /* Les numeros d'images peuvent etre translates. Lorsque tel est le cas, le numero           */
                                        /* d'image utilise est le numero translate modulo {premiere,derniere}.                       */
     DEFV(Logical,INIT(inverser_l_ordre_de_recuperation_des_images,INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES));
                                        /* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a :           */
                                        /*                                                                                           */
                                        /*                  FAUX    : l'image d'arriere-plan est la premiere de la liste,            */
                                        /*                  VRAI    : l'image d'arriere-plan est la derniere de la liste.            */
                                        /*                                                                                           */
     DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
                                        /* Nombre de chiffres codant le numero des images de la serie...                             */
     DEFV(Int,INIT(numero_d_image,UNDEF));
                                        /* Numero de l'image courante.                                                               */
     DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
                                        /* Pas de passage d'un numero d'image a une autre.                                           */
     DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
                                        /* Nom courant des images.                                                                   */
     DEFV(Logical,INIT(memoriser_le_Z_Buffer,MEMORISER_LE_Z_BUFFER));
                                        /* Indique si le 'Z-Buffer' doit etre fourni comme resultat ('VRAI'), ou bien oublie         */
                                        /* apres le calcul ('FAUX'). On notera que la sortie du 'Z-Buffer' peut etre redondante      */
                                        /* d'avec celle de l'accumulation proprement dite, mais que cela n'est plus vrai des que     */
                                        /* 'IL_NE_FAUT_PAS(binariser_les_images)'.                                                   */
     DEFV(Logical,INIT(memoriser_le_Z_Buffer_comme_une_image_standard,MEMORISER_LE_Z_BUFFER_COMME_UNE_IMAGE_STANDARD));
                                        /* Indique si le 'Z-Buffer' est fourni comme resultat, si ce dernier doit etre fourni en     */
                                        /* tant qu'image standard ('VRAI') ou pas ('FAUX').                                          */
     /*..............................................................................................................................*/
#define   GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard                                                             \
                    "zbuffer_standard=""zBuffer_standard=""Zbuffer_standard=""ZBuffer_standard=""Z-Buffer_standard="                    \
                                        /* Afin de raccourcir une ligne suivante (introduit le 20070223105727)...                    */

     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
                         GET_ARGUMENT_C("postfixe=",nom_postfixe);
                         GET_ARGUMENT_C("imageAZ=""AZ=",nom_imageAZ);
                         GET_ARGUMENT_C("imageR=""R=",nom_imageR);
                         GET_ARGUMENT_C("imageRZ=""RZ=",nom_imageRZ);
                         GET_ARGUMENT_I("premiere=",premiere_image);
                         GET_ARGUMENT_I("derniere=",derniere_image);
                         GET_ARGUMENT_I("pas=",pas_des_images);
                         GET_ARGUMENT_I("modulo=",translation_des_numeros_des_images);
                         GET_ARGUMENT_L("inverser=",inverser_l_ordre_de_recuperation_des_images);
                         GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
                         GET_ARGUMENT_L("zbuffer=""zBuffer=""Zbuffer=""ZBuffer=""Z-Buffer=",memoriser_le_Z_Buffer);
                         GET_ARGUMENT_L(GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard
                                       ,memoriser_le_Z_Buffer_comme_une_image_standard
                                        );
                         )
                    );

#undef    GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard

     CALi(Inoir(ImageR));
                                        /* Initialisation de l'image Resultat.                                                       */

     DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
          Bblock
          EGAL(nom_image
              ,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
                   ,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
                                                  ,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres)
                                                   )
                   ,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
                                                  ,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres)
                                                  ,nom_postfixe
                                                   )
                    )
               );
                                        /* Le 20221212114750, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'...           */

          Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_image))))
               Bblock
                                        /* 'ImageA' donne la couche a l'instant courant.                                             */
               EGAL(nom_image
                   ,chain_Aconcaten2_sauf_nom_pipe(nom_imageAZ
                                                  ,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres)
                                                   )
                    );
                                        /* Le 20221212114750, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'...           */

               Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA,nom_image))))
                    Bblock
                                        /* 'IFmageA' donne le 'Z-Buffer' a l'instant courant.                                        */
                    CALS(ImoveM_3D_volume(ImageR,ImageA,IFmageA));
                                        /* Et "cumul" en fonction du 'Z-Buffer'...                                                   */
                    Eblock
               ATes
                    Bblock
                    Test__CODE_ERREUR__ERREUR07;
                    Eblock
               ETes
               Eblock
          ATes
               Bblock
               Test__CODE_ERREUR__ERREUR07;
               Eblock
          ETes

          CALZ_FreCC(nom_image);
          Eblock
     EDoI

     CALi(Iupdate_image(nom_imageR,ImageR));

     Test(IL_FAUT(memoriser_le_Z_Buffer))
          Bblock
          Test(IL_FAUT(memoriser_le_Z_Buffer_comme_une_image_standard))
               Bblock
               CALS(Ifloat_std_du_Z_Buffer(ImageA));
                                        /* Conversion du 'Z-Buffer' en une image "standard"...                                       */
               CALi(Iupdate_image(nom_imageRZ,ImageA));
               Eblock
          ATes
               Bblock
               CALi(IupdateF_image(nom_imageRZ,Z_Buffer));
               Eblock
          ETes
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     RETU_Commande;
     Eblock
ECommande