/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N I T I A L I S A T I O N S  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrv/champs_5.17$I' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 1992??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N I T I A L I S A T I O N S   G E N E R A L E S  :                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   INITIALISATIONS_GENERALES                                                                                                     \
                    Bblock                                                                                                              \
                    DEFV(Logical,INIT(EnTete_de_sauvegardM ## PRINT_ATTENTION_____editer_les_messages                                   \
                                     ,PRINT_ATTENTION_____editer_les_messages                                                           \
                                      )                                                                                                 \
                         );                                                                                                             \
                    EGAL(PRINT_ATTENTION_____editer_les_messages,NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_ATTENTION);                        \
                                        /* Afin de ne pas editer les messages d'ATTENTION emis par 'SET_DIMENSIONS_2D(...)' via      */ \
                                        /* 'AVERTISSEMENT_SUR_LE_NON_REDIMENSIONNEMENT_DE_CERTAINES_IMAGES' ('v $xiii/Images$DEF').  */ \
                                                                                                                                        \
                    SET_ECHANTILLONNAGE(PAS_HORIZONTAL,PAS_VERTICAL);                                                                   \
                                        /* Definition du sous-echantillonnage des champs.                                            */ \
                    SET_DIMENSIONS_2D(Xmin_IMAGE,Xmax_IMAGE,Ymin_IMAGE,Ymax_IMAGE);                                                     \
                                        /* Dimensionnement des images a generer...                                                   */ \
                    INITIALISATION_POINT_3D(Lsource                                                                                     \
                                           ,X_DE_LA_SOURCE_LUMINEUSE                                                                    \
                                           ,Y_DE_LA_SOURCE_LUMINEUSE                                                                    \
                                           ,Z_DE_LA_SOURCE_LUMINEUSE                                                                    \
                                            );                                                                                          \
                                        /* Initialisation de la position de la source lumineuse...                                   */ \
                                                                                                                                        \
                    DEBUT_DE_L_INITIALISATION_DES_INTERPOLATIONS;                                                                       \
                                        /* Debut d'initialisation des differentes interpolations.                                    */ \
                                                                                                                                        \
                    EGAL(nombre_de_periodes_de_la_simulation,UN);                                                                       \
                                        /* Afin de corriger les initialisation anterieures correspondant a '$xrq/nucleon.L0$K' ; on  */ \
                                        /* notera qu'il est impossible de changer la valeur de 'NOMBRE_DE_PERIODES_DE_LA_SIMULATION' */ \
                                        /* non plus que l'initialisation de 'nombre_de_periodes_de_la_simulation' puisque tout cela  */ \
                                        /* est fait dans '$xrq/nucleon.L3$I'...                                                      */ \
                                                                                                                                        \
                    EGAL(PRINT_ATTENTION_____editer_les_messages,EnTete_de_sauvegardM ## PRINT_ATTENTION_____editer_les_messages);      \
                                        /* Restauration de 'PRINT_ATTENTION_____editer_les_messages'...                              */ \
                    Eblock                                                                                                              \
                                        /* Initialisations generales faites au tout debut...                                         */

#define   INITIALISATION_DE_LA_SYNTHESE_D_IMAGE                                                                                         \
                    Bblock                                                                                                              \
                    INITIALISATION_DE_BASE_DES_TROIS_COMPOSANTES_D_UNE_IMAGE;                                                           \
                                                                                                                                        \
                    Test(IL_FAUT(generer_les_trainees))                                                                                 \
                         Bblock                                                                                                         \
                         DEFV(genere_p,INIT(blanc_1,NIVEAU_UNDEF));                                                                     \
                         DEFV(genere_p,INIT(blanc_0,NIVEAU_UNDEF));                                                                     \
                                        /* De facon a voir l'attenuation du 'BLANC'...                                               */ \
                         DEFV(Logical,INIT(on_a_trouve_la_periode_d_attenuation_des_trainees                                            \
                                          ,COND(IFLT(facteur_d_attenuation_des_trainees,PONDERATION_MAXIMALE_DES_TRAINEES),FAUX,VRAI)   \
                                           )                                                                                            \
                              );                                                                                                        \
                                        /* A priori, on n'a pas encore trouve la periode d'attenuation des trainees, sauf si le      */ \
                                        /* facteur d'attenuation est plus grand ou egal a 1...                                       */ \
                                                                                                                                        \
                         EGAL(periode_d_attenuation_des_trainees,UN);                                                                   \
                                        /* A priori, la periode est de 1...                                                          */ \
                                                                                                                                        \
                         Tant(EST_FAUX(on_a_trouve_la_periode_d_attenuation_des_trainees))                                              \
                              Bblock                                                                                                    \
                              EGAL(blanc_1                                                                                              \
                                  ,ATTENUATION_DE_TRAINEES(PUIX(facteur_d_attenuation_des_trainees                                      \
                                                               ,ADD2(periode_d_attenuation_des_trainees,UN)                             \
                                                                )                                                                       \
                                                          ,BLANC                                                                        \
                                                           )                                                                            \
                                   );                                                                                                   \
                              EGAL(blanc_0                                                                                              \
                                  ,ATTENUATION_DE_TRAINEES(PUIX(facteur_d_attenuation_des_trainees                                      \
                                                               ,ADD2(periode_d_attenuation_des_trainees,ZERO)                           \
                                                                )                                                                       \
                                                          ,BLANC                                                                        \
                                                           )                                                                            \
                                   );                                                                                                   \
                                        /* Etude de l'attenuation du 'BLANC'.                                                        */ \
                                                                                                                                        \
                              Test(IFGE(blanc_1,blanc_0))                                                                               \
                                   Bblock                                                                                               \
                                   INCR(periode_d_attenuation_des_trainees,I);                                                          \
                                        /* Tant que l'on ne peut distinguer 'blanc_1' de 'blanc_0', on augmente la periode...        */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   EGAL(on_a_trouve_la_periode_d_attenuation_des_trainees,VRAI);                                        \
                                        /* Des que l'on ne peut distinguer 'blanc_1' de 'blanc_0', on connait la periode...          */ \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETan                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_ROUGE,Image_ROUGE);                                     \
                    MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_VERTE,Image_VERTE);                                     \
                    MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_BLEUE,Image_BLEUE);                                     \
                                        /* Initialisation eventuelle du calcul des trainees...                                       */ \
                                                                                                                                        \
                    INITIALISATION_DU_ZOOM_AUTOMATIQUE;                                                                                 \
                                        /* Mis sous cette forme le 20131114165226...                                                 */ \
                    Eblock                                                                                                              \
                                        /* Initialisation de la synthese d'image...                                                  */

#define   INITIALISATION_DU_ZOOM_AUTOMATIQUE                                                                                            \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(zoom_automatique))                                                                                     \
                         Bblock                                                                                                         \
                         DEFV(Logical,INIT(on_a_trouve_le_rapport_de_zoom_automatique,FAUX));                                           \
                                        /* A priori, on n'a pas encore trouve le rapport de zoom automatique.                        */ \
                                                                                                                                        \
                         EGAL(rapport_automatique_du_zoom,zoom_automatique_maximal);                                                    \
                                        /* Initialisation du processus.                                                              */ \
                         INITIALISATION_SYSTEMATIQUE_TRANSFORMATION;                                                                    \
                         T_ZOOM(rapport_automatique_du_zoom);                                                                           \
                                        /* A cause de 'TRANSFORMATION_GEOMETRIQUE_3D_F?(...)' qui suivent...                         */ \
                                                                                                                                        \
                         Tant(EST_FAUX(on_a_trouve_le_rapport_de_zoom_automatique))                                                     \
                              Bblock                                                                                                    \
                              DEFV(Float,INIT(Xf_BG,TRANSFORMATION_GEOMETRIQUE_3D_Fx(ASD2(espace_physique,origine,x)                    \
                                                                                    ,ASD2(espace_physique,origine,y)                    \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                              DEFV(Float,INIT(Yf_BG,TRANSFORMATION_GEOMETRIQUE_3D_Fy(ASD2(espace_physique,origine,x)                    \
                                                                                    ,ASD2(espace_physique,origine,y)                    \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                              DEFV(Float,INIT(Zf_BG,TRANSFORMATION_GEOMETRIQUE_3D_Fz(ASD2(espace_physique,origine,x)                    \
                                                                                    ,ASD2(espace_physique,origine,y)                    \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                                        /* Definition du coin Bas-Gauche du plan de l'espace passant par le centre et exprime        */ \
                                        /* dans les coordonnees de l'univers.                                                        */ \
                              DEFV(Float,INIT(Xf_HD,TRANSFORMATION_GEOMETRIQUE_3D_Fx(ASD2(espace_physique,extremite,x)                  \
                                                                                    ,ASD2(espace_physique,extremite,y)                  \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                              DEFV(Float,INIT(Yf_HD,TRANSFORMATION_GEOMETRIQUE_3D_Fy(ASD2(espace_physique,extremite,x)                  \
                                                                                    ,ASD2(espace_physique,extremite,y)                  \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                              DEFV(Float,INIT(Zf_HD,TRANSFORMATION_GEOMETRIQUE_3D_Fz(ASD2(espace_physique,extremite,x)                  \
                                                                                    ,ASD2(espace_physique,extremite,y)                  \
                                                                                    ,Z_de_calcul_du_zoom_automatique                    \
                                                                                    ,FZERO                                              \
                                                                                     )                                                  \
                                              )                                                                                         \
                                   );                                                                                                   \
                                        /* Definition du coin Haut-Droite du plan de l'espace passant par le centre et exprime       */ \
                                        /* dans les coordonnees de l'univers.                                                        */ \
                              DEFV(Int,INIT(X_BG                                                                                        \
                                           ,INTE(X_DE_VISUALISATION(Projection_OX(X_PHYSIQUE_DANS_01(Xf_BG)                             \
                                                                                 ,Y_PHYSIQUE_DANS_01(Yf_BG)                             \
                                                                                 ,Z_PHYSIQUE_DANS_01(Zf_BG)                             \
                                                                                  )                                                     \
                                                                    )                                                                   \
                                                 )                                                                                      \
                                            )                                                                                           \
                                   );                                                                                                   \
                              DEFV(Int,INIT(Y_BG                                                                                        \
                                           ,INTE(Y_DE_VISUALISATION(Projection_OY(X_PHYSIQUE_DANS_01(Xf_BG)                             \
                                                                                 ,Y_PHYSIQUE_DANS_01(Yf_BG)                             \
                                                                                 ,Z_PHYSIQUE_DANS_01(Zf_BG)                             \
                                                                                  )                                                     \
                                                                    )                                                                   \
                                                 )                                                                                      \
                                            )                                                                                           \
                                   );                                                                                                   \
                                        /* Definition du coin Bas-Gauche du plan de l'espace passant par le centre et exprime        */ \
                                        /* dans les coordonnees de l'image.                                                          */ \
                              DEFV(Int,INIT(X_HD                                                                                        \
                                           ,INTE(X_DE_VISUALISATION(Projection_OX(X_PHYSIQUE_DANS_01(Xf_HD)                             \
                                                                                 ,Y_PHYSIQUE_DANS_01(Yf_HD)                             \
                                                                                 ,Z_PHYSIQUE_DANS_01(Zf_HD)                             \
                                                                                  )                                                     \
                                                                    )                                                                   \
                                                 )                                                                                      \
                                            )                                                                                           \
                                   );                                                                                                   \
                              DEFV(Int,INIT(Y_HD                                                                                        \
                                           ,INTE(Y_DE_VISUALISATION(Projection_OY(X_PHYSIQUE_DANS_01(Xf_HD)                             \
                                                                                 ,Y_PHYSIQUE_DANS_01(Yf_HD)                             \
                                                                                 ,Z_PHYSIQUE_DANS_01(Zf_HD)                             \
                                                                                  )                                                     \
                                                                    )                                                                   \
                                                 )                                                                                      \
                                            )                                                                                           \
                                   );                                                                                                   \
                                        /* Definition du coin Haut-Droite du plan de l'espace passant par le centre et exprime       */ \
                                        /* dans les coordonnees de l'image.                                                          */ \
                                                                                                                                        \
                              Test(IFOU(TEST_HORS_IMAGE(X_BG,Y_BG),TEST_HORS_IMAGE(X_HD,Y_HD)))                                         \
                                   Bblock                                                                                               \
                                   EGAL(rapport_automatique_du_zoom                                                                     \
                                       ,EXPB(SOUS(LOGX(rapport_automatique_du_zoom),finesse_de_calcul_du_zoom_automatique))             \
                                        );                                                                                              \
                                        /* Tant que la diagonale de l'espace dans le plan central n'est pas entierement dans         */ \
                                        /* l'image, on reduit le rapport de zoom "automatique"...                                    */ \
                                   INITIALISATION_SYSTEMATIQUE_TRANSFORMATION;                                                          \
                                   T_ZOOM(rapport_automatique_du_zoom);                                                                 \
                                        /* Tout ceci afin de ne pas cumuler tout les rapports de zoom successifs...                  */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   EGAL(on_a_trouve_le_rapport_de_zoom_automatique,VRAI);                                               \
                                        /* Des que la diagonale de l'espace dans le plan central est entierement contenue dans       */ \
                                        /* l'image, on s'arrete sur ce rapport de zoom.                                              */ \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETan                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Initialisation du zoom automatique (introduite sous cette forme "separee" le              */ \
                                        /* 20131114165226 pour 'v $xrv/particule.10$K INITIALISATION_DU_ZOOM_AUTOMATIQUE').          */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N I T I A L I S A T I O N S   R E L A T I V E S   A   C H A Q U E   N O U V E L L E   I M A G E  :                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   INITIALISATION_DE_BASE_DES_TROIS_COMPOSANTES_D_UNE_IMAGE                                                                      \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(generer_un_effet_de_brume))                                                                            \
                         Bblock                                                                                                         \
                         CALi(Iblanc(Image_ROUGE));                                                                                     \
                         CALi(Iblanc(Image_VERTE));                                                                                     \
                         CALi(Iblanc(Image_BLEUE));                                                                                     \
                                        /* Nettoyage : fond BLANC lorsqu'un effet de brume est demande (cette initialisation est due */ \
                                        /* au fait qu'apres l'application de la brume, le fond de l'image sera blanc ; afin que le   */ \
                                        /* traitement de l'aliasing soit correct, il faut que le fond initial de l'image utilise     */ \
                                        /* pour tracer les spheres soit aussi celui de la version finale des images...).             */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         CALi(Inoir(Image_ROUGE));                                                                                      \
                         CALi(Inoir(Image_VERTE));                                                                                      \
                         CALi(Inoir(Image_BLEUE));                                                                                      \
                                        /* Nettoyage : fond NOIR lorsqu'un effet de brume n'est pas demande.                         */ \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Initialisation de base des trois composantes de l'image a generer...                      */

#ifdef    __VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND
                                        /* Le nom 'PERMETTRE_L_UTILISATION_D_UN_FOND' a ete change le 20030313152029 en              */
                                        /* '__VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND' afin de permettre sa recuperation          */
                                        /* dans 'v $xcc/cpp$Z _VERSION_'.                                                            */
#    define    METTRE_UN_FOND                                                                                                           \
                         FAUX
#    define    INVERSER_LE_FOND                                                                                                         \
                         FAUX
#    define    LE_FOND_EST_DYNAMIQUE                                                                                                    \
                         FAUX
#    define    FACTEUR_DU_FOND                                                                                                          \
                         FU
#    define    TRANSLATION_DU_FOND                                                                                                      \
                         FZERO
#    define    LE_FOND_A_UN_Z_BUFFER                                                                                                    \
                         FAUX

#    define    DONNEES_NECESSAIRES_A_L_UTILISATION_D_UN_FOND                                                                            \
                         DEFV(Logical,INIT(mettre_un_fond,METTRE_UN_FOND));                                                             \
                                        /* Indique s'il faut mettre ('VRAI') ou pas ('FAUX') un fond derriere chaque image generee.  */ \
                         DEFV(Logical,INIT(inverser_le_fond,INVERSER_LE_FOND));                                                         \
                                        /* Indique, lorsque 'IL_FAUT(mettre_un_fond)', si le fond doit etre inverse ('VRAI') ou      */ \
                                        /* pas ('FAUX').                                                                             */ \
                         DEFV(Logical,INIT(le_fond_est_dynamique,LE_FOND_EST_DYNAMIQUE));                                               \
                                        /* Indique, lorsqu'un fond est demande, si celui-ci est statique ('FAUX'), c'est-a-dire      */ \
                                        /* n'evolue pas d'image en image, ou bien est dynamique ('VRAI'), et donc est lui-meme       */ \
                                        /* constitue d'une suite d'images. Cet indicateur controle aussi le 'Z-Buffer' eventuel.     */ \
                         DEFV(Float,INIT(facteur_du_fond,FACTEUR_DU_FOND));                                                             \
                         DEFV(Float,INIT(translation_du_fond,TRANSLATION_DU_FOND));                                                     \
                                        /* Indique respectivement le facteur et la translation du fond...                            */ \
                         DEFV(CHAR,INIC(POINTERc(nom_imageF),NOM_PIPE));                                                                \
                                        /* Nom du fond a utiliser eventuellement derriere chaque image generee.                      */ \
                         DEFV(Logical,INIT(le_fond_a_un_Z_Buffer,LE_FOND_A_UN_Z_BUFFER));                                               \
                                        /* Indique si le fond possede un 'Z-Buffer' ('VRAI') ou pas ('FAUX').                        */ \
                         DEFV(CHAR,INIC(POINTERc(nom_imageZF),NOM_PIPE));                                                               \
                                        /* Nom du 'Z-Buffer' du fond a utiliser eventuellement. L'indicateur 'le_fond_est_dynamique' */ \
                                        /* s'applique a lui aussi...                                                                 */

#    define    NOM_D_UNE_COMPOSANTE_DU_FOND(numero_image,composante)                                                                    \
                         COND(EST_VRAI(le_fond_est_dynamique)                                                                           \
                             ,chain_Aconcaten3_sauf_nom_pipe(nom_imageF                                                                 \
                                                            ,NUMERO_IMAGE(numero_image)                                                 \
                                                            ,composante                                                                 \
                                                             )                                                                          \
                             ,chain_Aconcaten2_sauf_nom_pipe(nom_imageF                                                                 \
                                                            ,composante                                                                 \
                                                             )                                                                          \
                              )                                                                                                         \
                                        /* Generation du nom d'une composante du fond...                                             */
#    define    CHARGEMENT_D_UNE_COMPOSANTE_DU_FOND(generer_la_composante,fond_Image,numero_image,composante)                            \
                         Bblock                                                                                                         \
                         Test(IFET(IL_FAUT(generer_la_composante)                                                                       \
                                  ,PAS_D_ERREUR(CODE_ERROR(Iload_image(fond_Image                                                       \
                                                                      ,NOM_D_UNE_COMPOSANTE_DU_FOND(numero_image,composante)            \
                                                                       )                                                                \
                                                           )                                                                            \
                                                )                                                                                       \
                                   )                                                                                                    \
                              )                                                                                                         \
                              Bblock                                                                                                    \
                              Test(IL_FAUT(inverser_le_fond))                                                                           \
                                   Bblock                                                                                               \
                                   CALi(Icomplementation(fond_Image,fond_Image));                                                       \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              CALi(Inoir(fond_Image));                                                                                  \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                                        /* Chargement d'une composante du fond avec initialisation en cas d'erreur...                */
#    define    INITIALISATION_DES_TROIS_COMPOSANTES_D_UNE_IMAGE(numero_image)                                                           \
                         Bblock                                                                                                         \
                         INITIALISATION_DE_BASE_DES_TROIS_COMPOSANTES_D_UNE_IMAGE;                                                      \
                                        /* Initialisation a priori (meme si un fond est necessaire, et ce au cas ou il n'existerait  */ \
                                        /* pas...).                                                                                  */ \
                         Test(IL_FAUT(mettre_un_fond))                                                                                  \
                              Bblock                                                                                                    \
                              BDEFV(image,fond_Image_ROUGE);                                                                            \
                              BDEFV(image,fond_Image_VERTE);                                                                            \
                              BDEFV(image,fond_Image_BLEUE);                                                                            \
                                        /* Definition des trois fonds a charger...                                                   */ \
                                                                                                                                        \
                              CHARGEMENT_D_UNE_COMPOSANTE_DU_FOND(generer_la_composante_ROUGE,fond_Image_ROUGE,numero_image,c_ROUGE);   \
                              CHARGEMENT_D_UNE_COMPOSANTE_DU_FOND(generer_la_composante_VERTE,fond_Image_VERTE,numero_image,c_VERTE);   \
                              CHARGEMENT_D_UNE_COMPOSANTE_DU_FOND(generer_la_composante_BLEUE,fond_Image_BLEUE,numero_image,c_BLEUE);   \
                                        /* Chargement du fond dynamique ou statique demande.                                         */ \
                                                                                                                                        \
                              CALS(Iscale(Image_ROUGE,facteur_du_fond,fond_Image_ROUGE,translation_du_fond));                           \
                              CALS(Iscale(Image_VERTE,facteur_du_fond,fond_Image_VERTE,translation_du_fond));                           \
                              CALS(Iscale(Image_BLEUE,facteur_du_fond,fond_Image_BLEUE,translation_du_fond));                           \
                                        /* Enfin, modification eventuelle du fond...                                                 */ \
                                                                                                                                        \
                              EDEFV(image,fond_Image_BLEUE);                                                                            \
                              EDEFV(image,fond_Image_VERTE);                                                                            \
                              EDEFV(image,fond_Image_ROUGE);                                                                            \
                                        /* Definition des trois fonds a charger...                                                   */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                                        /* Initialisation des trois composantes de l'image a generer...                              */
#Aifdef   __VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND
#    define    INITIALISATION_DES_TROIS_COMPOSANTES_D_UNE_IMAGE(numero_image)                                                           \
                         Bblock                                                                                                         \
                         INITIALISATION_DE_BASE_DES_TROIS_COMPOSANTES_D_UNE_IMAGE;                                                      \
                         Eblock                                                                                                         \
                                        /* Initialisation des trois composantes de l'image a generer...                              */
#Eifdef   __VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND

#define   INITIALISATIONS_RELATIVES_A_CHAQUE_NOUVELLE_IMAGE(numero_image)                                                               \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(zoom_automatique))                                                                                     \
                         Bblock                                                                                                         \
                         Test(IFEQ(rapport_automatique_du_zoom,FLOT__UNDEF))                                                            \
                              Bblock                                                                                                    \
                              PRINT_ATTENTION("le zoom automatique n'est pas disponible ici, il est donc desactive");                   \
                              EGAL(zoom_automatique,FAUX);                                                                              \
                                        /* Dispositif introduit le 20110322120951 a cause de 'v $xrv/particule.10$K' qui n'utilise   */ \
                                        /* pas 'v $xrv/champs_5.17$I INITIALISATION_DE_LA_SYNTHESE_D_IMAGE' (comme beaucoup d'autres */ \
                                        /* '$K' d'ailleurs...) et qui donc ne peut pas calculer automatiquement le rapport de zoom.  */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    INITIALISATION_DES_TROIS_COMPOSANTES_D_UNE_IMAGE(numero_image);                                                     \
                                        /* Initialisation des trois composantes de l'image a generer...                              */ \
                                                                                                                                        \
                    SET_NOIR_PLANCHER(NOIR_PLANCHER);                                                                                   \
                    INITIALISATION_TRANSFORMATION;                                                                                      \
                                        /* Initialisation de la transformation tri-dimensionnelle courante.                          */ \
                    SET_FACTEUR_D_ELOIGNEMENT_EN_Z_DE_L_OBSERVATEUR(facteur_en_Z_de_l_observateur);                                     \
                                        /* Facteur d'eloignement en 'Z' de l'observateur destine a une projection "standard"...      */ \
                                                                                                                                        \
                    CHANGEMENT_DU_POINT_DE_VUE;                                                                                         \
                                        /* Positionnement de l'observateur.                                                          */ \
                                                                                                                                        \
                    SET_DECALAGE_ANGULAIRE_DE_L_OBSERVATEUR(decalage_angulaire_pour_la_stereoscopie);                                   \
                                        /* Initialisation du facteur de rotation de l'observateur permettant ainsi de creer          */ \
                                        /* des paires stereoscopiques. ATTENTION, l'ordre suivant est imperatif :                    */ \
                                        /*                                                                                           */ \
                                        /*                  CHANGEMENT_DU_POINT_DE_VUE;                                              */ \
                                        /*                  SET_DECALAGE_ANGULAIRE_DE_L_OBSERVATEUR(...);                            */ \
                                        /*                                                                                           */ \
                                        /* car la premiere procedure peut changer 'decalage_angulaire_pour_la_stereoscopie' via la   */ \
                                        /* fonction 'vTRANSFORMAT_31(...,sSTEREOSCOPIE(...))'.                                       */ \
                                                                                                                                        \
                    PREPARATION_DE_L_INITIALISATION_DU_Z_BUFFER;                                                                        \
                                        /* Initialisation de la future valeur d'initialisation du 'Z-Buffer'...                      */ \
                    INITIALISATION_DE_LA_LISTE_DES_POINTS;                                                                              \
                                        /* (re-)initialisation de l'index de rangement dans la liste de tri des spheres...           */ \
                    Eblock                                                                                                              \
                                        /* Initialisations necessaires avant le calcul et la generation de chaque nouvelle image.    */



Copyright © Jean-François Colonna, 2019-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019-2021.