/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A F F I C H A G E   D ' U N E   I M A G E   E N   V R A I E S   C O U L E U R S  :                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Cette commande affiche une                                                                                     */
/*                  image Argument en vraies couleurs                                                                                */
/*                  dans une fenetre.                                                                                                */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*             *     * * * * * *   * * * * * *   * * * * * *   *         *   * * * * * *   *   * * * * * *   *         *             */
/*                        *             *        *             **        *        *        *   *         *   **        *             */
/*            * *         *             *        *             * *       *        *        *   *         *   * *       *             */
/*                        *             *        *             *  *      *        *        *   *         *   *  *      *             */
/*           *   *        *             *        *             *   *     *        *        *   *         *   *   *     *             */
/*                        *             *        * * *         *    *    *        *        *   *         *   *    *    *             */
/*          * * * *       *             *        *             *     *   *        *        *   *         *   *     *   *             */
/*                        *             *        *             *      *  *        *        *   *         *   *      *  *             */
/*         *       *      *             *        *             *       * *        *        *   *         *   *       * *             */
/*                        *             *        *             *        **        *        *   *         *   *        **             */
/*        *         *     *             *        * * * * * *   *         *        *        *   * * * * * *   *         *             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        ATTENTION :                                                                                                                */
/*                                                                                                                                   */
/*                    On notera qu'il s'agit la d'une                                                                                */
/*                  version simplifiee de '$xci/display_RVB$K'                                                                       */
/*                  destinee principalement a '$xci/disk_video_P$Z'                                                                  */
/*                  et ce uniquement sur 'SYSTEME_SG...' afin                                                                        */
/*                  d'eviter des problemes largement documentes                                                                      */
/*                  avec le 'vswap'...                                                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xci/Sdisplay_RVB$K' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 1995??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#    include   image_image_QUAD_IMAGE_EXT

#    nodefine  INCLURE_LE_GRAPHIQUE_X_WINDOW

#    ifdef     __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
#    Aifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
#    Eifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL

#    ifdef     __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#         define    INCLURE_LE_GRAPHIQUE_X_WINDOW
#    Aifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#    Eifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL

#    nodefine  L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE

#    ifdef     __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS
                                        /* ATTENTION, il est impossible d'ecrire ici :                                               */
                                        /*                                                                                           */
                                        /*        #    if        (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_...))    \  */
                                        /*                        )                                                                  */
                                        /*                  (...)                                                                    */
                                        /*        #    Aif       (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_...))    \  */
                                        /*                        )                                                                  */
                                        /*        #    Eif       (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_...))    \  */
                                        /*                        )                                                                  */
                                        /*                                                                                           */
                                        /* a cause de '$xcc/cl$Z' lors de la recuperation des includes conditionnels...              */

#         ifdef     GESTION_DE_L_OPTION_GALILEO_VERSION_02

#              ifdef     __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

#                   ifndef    INCLURE_LE_GRAPHIQUE_X_WINDOW
#                        define    INCLURE_LE_GRAPHIQUE_X_WINDOW
#                   Aifndef   INCLURE_LE_GRAPHIQUE_X_WINDOW
#                   Eifndef   INCLURE_LE_GRAPHIQUE_X_WINDOW

#                   define    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
#              Aifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#              Eifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

#         Aifdef    GESTION_DE_L_OPTION_GALILEO_VERSION_02
#         Eifdef    GESTION_DE_L_OPTION_GALILEO_VERSION_02

#    Aifdef    __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS
#    Eifdef    __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS

#    ifdef     INCLURE_LE_GRAPHIQUE_X_WINDOW
#         include   image_drive_XWind_FONCTION_EXT
#    Aifdef    INCLURE_LE_GRAPHIQUE_X_WINDOW
#    Eifdef    INCLURE_LE_GRAPHIQUE_X_WINDOW

#    include   image_drive_SiliG_FONCTION_1_EXT
                                        /* ATTENTION, l'ordre suivant est imperatif :                                                */
                                        /*                                                                                           */
                                        /*                  #              include   image_drive_XWind_FONCTION_EXT                  */
                                        /*                  #         include   image_drive_SiliG_FONCTION_1_EXT                     */
                                        /*                                                                                           */
                                        /* a cause des references de 'XWind' par 'SiliG'...                                          */

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#    define    CENTRER_LA_FENETRE                                                                                                       \
                         FAUX                                                                                                           \
                                        /* Faut-il centrer la fenetre ('VRAI') ou pas ('FAUX').                                      */
#    define    CORRIGER_LE_GAMMA                                                                                                        \
                         FAUX                                                                                                           \
                                        /* A priori, on ne touchera pas a la correction de gamma.                                    */
#    define    CORRECTION_DE_GAMMA_ROUGE                                                                                                \
                         FU
#    define    CORRECTION_DE_GAMMA_VERTE                                                                                                \
                         FU
#    define    CORRECTION_DE_GAMMA_BLEUE                                                                                                \
                         FU
                                        /* Corrections de gamma implicites.                                                          */

#    define    GENERER_DE_LA_VIDEO                                                                                                      \
                         FAUX                                                                                                           \
                                        /* De la video "standard" 780x575 ('VRAI') ou de la "haute-definition" 1280x1024 ('FAUX').   */
#    define    LAISSER_LE_CURSEUR_APPARAITRE_PENDANT_L_AFFICHAGE                                                                        \
                         FAUX                                                                                                           \
                                        /* Indicateur precisant s'il faut laisser le curseur de l'ecran pendant que cette fenetre    */ \
                                        /* est ouverte ('VRAI') ou le supprimer ('FAUX').                                            */

#    define    REDIMENSIONNER_LES_IMAGES_RVB                                                                                            \
                         FAUX                                                                                                           \
                                        /* Les images 'RVB' doivent-elles etre redimensionnees ('VRAI') ou pas ('FAUX').             */
#    define    METHODE_DE_REECHANTILLONNAGE_A_UTILISER                                                                                  \
                         METHODE_IMPLICITE_DE_REECHANTILLONNAGE                                                                         \
                                        /* Methode de redimensionnement a utiliser alors...                                          */
#    define    CONSERVER_LES_PROPORTIONS_LORS_D_UN_REDIMENSIONNEMENT                                                                    \
                         FAUX                                                                                                           \
                                        /* Faut-il conserver ('VRAI') ou pas ('FAUX') les proportions de l'image Argument. La        */ \
                                        /* valeur implicite ('FAUX') permet d'occuper tout l'ecran, et ce quelle que soit l'image    */ \
                                        /* Argument...                                                                               */

#    ifdef     L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
#         define    SERVEUR_STANDARD                                                                                                    \
                              DEFINITION_DU_SERVEUR_X_WINDOW                                                                            \
                                        /* Le serveur standard est celui qui est defini par la variable "DISPLAY".                   */

#         define    EDITER_LES_PRINT_ATTENTION_INITIAUX                                                                                 \
                              FAUX                                                                                                      \
                                        /* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis         */ \
                                        /* ('VRAI') ou pas ('FAUX').                                                                 */
#         define    SIGNALER_LES_EVENEMENTS_INATTENDUS                                                                                  \
                              NE_PAS_SIGNALER_LES_EVENEMENTS_INATTENDUS_DE_X_WINDOW                                                     \
                                        /* Indique si les evenements inattendus de 'X-Window' doivent etre signales ('VRAI') ou pas  */ \
                                        /* ('FAUX').                                                                                 */

#         define    CENTRER_LA_FENETRE_VIDEO_TEMPS_REEL                                                                                 \
                              VRAI                                                                                                      \
                                        /* Faut-il centrer la fenetre video temps reel ('VRAI') ou bien donner explicitement la      */ \
                                        /* position de son coin "bas gauche" ('FAUX') ?                                              */
#         define    X_COIN_BAS_GAUCHE                                                                                                   \
                              Xmin11                                                                                                    \
                                        /* Definition du coin bas gauche de la fenetre...                                            */
#         define    Y_COIN_BAS_GAUCHE                                                                                                   \
                              Ymin11                                                                                                    \
                                        /* Definition du coin bas gauche de la fenetre...                                            */

#         define    ENTREE_VIDEO_TEMPS_REEL                                                                                             \
                              FAUX                                                                                                      \
                                        /* De la video va-t-elle etre entree ('VRAI') ou pas ('FAUX')...                             */
#         define    NUMERISER_UNE_IMAGE                                                                                                 \
                              FAUX                                                                                                      \
                                        /* Si de la video entre, faut-il numeriser une image ('VRAI') ou pas ('FAUX')...             */

#define   ENTREE_DES_ARGUMENTS_DE_L_ENTREE_VIDEO_TEMPS_REEL                                                                             \
                    Bblock                                                                                                              \
                    GET_ARGUMENT_L("genlock=",SGI_____se_synchroniser_sur_une_source_externe);                                          \
                    GET_ARGUMENT_L("blocage=",SGI_____bloquer_la_generation_video_si_defaut_en_cours_de_transfert);                     \
                    GET_ARGUMENT_L("station=",SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail);                       \
                    GET_ARGUMENT_I("blank=",SGI_____nombre_de_lignes_blankees);                                                         \
                    GET_ARGUMENT_I("decalageV=""Vphase=",SGI_____decalage_de_VL_EV1_V_OFFSET);                                          \
                    GET_ARGUMENT_I("Hphase=",SGI_____decalage_de_VL_EV1_H_OFFSET);                                                      \
                    Eblock                                                                                                              \
                                        /* Entree des parametres de l'entree video temps reel...                                     */
#    Aifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
#         define    SERVEUR_STANDARD                                                                                                    \
                              NOM_UNDEF                                                                                                 \
                                        /* Le serveur standard est celui qui est defini par la variable "DISPLAY".                   */

#         define    EDITER_LES_PRINT_ATTENTION_INITIAUX                                                                                 \
                              FAUX                                                                                                      \
                                        /* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis         */ \
                                        /* ('VRAI') ou pas ('FAUX').                                                                 */
#         define    X_COIN_BAS_GAUCHE                                                                                                   \
                              UNDEF                                                                                                     \
                                        /* Definition du coin bas gauche de la fenetre...                                            */
#         define    Y_COIN_BAS_GAUCHE                                                                                                   \
                              UNDEF                                                                                                     \
                                        /* Definition du coin bas gauche de la fenetre...                                            */

#         define    ENTREE_VIDEO_TEMPS_REEL                                                                                             \
                              FAUX                                                                                                      \
                                        /* De la video va-t-elle etre entree ('VRAI') ou pas ('FAUX')...                             */

#define   ENTREE_DES_ARGUMENTS_DE_L_ENTREE_VIDEO_TEMPS_REEL                                                                             \
                    Bblock                                                                                                              \
                    BLOC(VIDE;);                                                                                                        \
                    Eblock                                                                                                              \
                                        /* Entree des parametres de l'entree video temps reel...                                     */
#    Eifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE

#    if        (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS))                                  \
                )
#              redefine  LAISSER_LE_CURSEUR_APPARAITRE_PENDANT_L_AFFICHAGE                                                              \
                                   VRAI                                                                                                 \
                                        /* Indicateur precisant s'il faut laisser le curseur de l'ecran pendant que cette fenetre    */ \
                                        /* est ouverte ('VRAI') ou le supprimer ('FAUX').                                            */
#    Aif       (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS))                                  \
                )
#    Eif       (         (defined(__VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS))                                  \
                )

#    define    TRANSLATION_OX_DE_LA_FENETRE                                                                                             \
                         _____cNORMALISE_OXG(CGXR(XminG))                                                                               \
                                        /* Translation horizontale implicite de la fenetre,                                          */
#    define    TRANSLATION_OY_DE_LA_FENETRE                                                                                             \
                         _____cNORMALISE_OYG(CGYR(YminG))                                                                               \
                                        /* Translation verticale implicite de la fenetre.                                            */
#    define    CENTRER_L_IMAGE_DANS_LA_FENETRE                                                                                          \
                         VRAI                                                                                                           \
                                        /* Centrer ou pas (il faut alors la translation suivante) l'image dans la fenetre...         */
#    define    TRANSLATION_OX_DE_L_IMAGE_DANS_LA_FENETRE                                                                                \
                         _____cNORMALISE_OXG(CGXR(XminG))                                                                               \
                                        /* Translation horizontale implicite de l'image dans la fenetre,                             */
#    define    TRANSLATION_OY_DE_L_IMAGE_DANS_LA_FENETRE                                                                                \
                         _____cNORMALISE_OYG(CGYR(YminG))                                                                               \
                                        /* Translation verticale implicite de l'image dans la fenetre.                               */
#    define    FACTEUR_DE_ZOOM                                                                                                          \
                         RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom                                                                           \
                                        /* Facteur de zoom de l'image.                                                               */
#    define    MINIMUM_DE_LA_LUMINANCE                                                                                                  \
                         NOIR
#    define    MAXIMUM_DE_LA_LUMINANCE                                                                                                  \
                         BLANC
                                        /* Minimum et maximum demande pour chaque point (a l'exception des points 'NOIR').           */
#    define    NOM_DE_LA_FENETRE                                                                                                        \
                         "image"                                                                                                        \
                                        /* Nom de la fenetre...                                                                      */
#    define    SYNCHRONISATION_EXTERNE                                                                                                  \
                         FAUX                                                                                                           \
                                        /* Indique s'il y a une attente implicite par 'DUREE_D_ATTENTE' ('FAUX') ou bien une         */ \
                                        /* synchronisation sur un signal externe par 'ATTENDRE_AU_FEU_ROUGE' ('VRAI').               */
#    define    DUREE_D_ATTENTE                                                                                                          \
                         SOIXANTE                                                                                                       \
                                        /* Attente implicite avant d'effacer l'image.                                                */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#    define    OUVERTURE_DE_LA_FENETRE                                                                                                  \
                         Bblock                                                                                                         \
                         CALS(IGopen(nom_de_la_fenetre                                                                                  \
                                    ,centrer_la_fenetre                                                                                 \
                                    ,ADRESSE(translation_de_la_fenetre)                                                                 \
                                    ,generer_de_la_video                                                                                \
                                    ,laisser_le_curseur_apparaitre_pendant_l_affichage                                                  \
                                     )                                                                                                  \
                              );                                                                                                        \
                                        /* Ouverture du plan de travail.                                                             */ \
                                                                                                                                        \
                         Test(IL_FAUT(corriger_le_gamma))                                                                               \
                              Bblock                                                                                                    \
                              CALS(IGchangement_de_la_correction_de_gamma(correction_de_gamma_ROUGE                                     \
                                                                         ,correction_de_gamma_VERTE                                     \
                                                                         ,correction_de_gamma_BLEUE                                     \
                                                                          )                                                             \
                                   );                                                                                                   \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                                        /* Ouverture d'une fenetre...                                                                */
#    define    FERMETURE_DE_LA_FENETRE                                                                                                  \
                         Bblock                                                                                                         \
                         CALS(IGclose());                                                                                               \
                                        /* Fermeture du plan de travail.                                                             */ \
                         Eblock                                                                                                         \
                                        /* Fermeture d'une fenetre...                                                                */

#    define    REDIMENSIONNEMENT(imageR,imageA)                                                                                         \
                         Bblock                                                                                                         \
                         CALS(Iredimensionnement(imageR                                                                                 \
                                                ,XminRedim,XmaxRedim,YminRedim,YmaxRedim                                                \
                                                ,imageA                                                                                 \
                                                ,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax                              \
                                                ,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax                              \
                                                ,methode_de_redimensionnement_a_utiliser                                                \
                                                 )                                                                                      \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                                        /* Redimensionnement d'un image...                                                           */

#    ifdef     __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
#         define    CONVERSION_D_UNE_IMAGE_QUELCONQUE(image_ROUGE,image_VERTE,image_BLEUE)                                              \
                              Bblock                                                                                                    \
                              Test(IFET(IFEQ(minimum_de_la_luminance,MINIMUM_DE_LA_LUMINANCE)                                           \
                                       ,IFEQ(maximum_de_la_luminance,MAXIMUM_DE_LA_LUMINANCE)                                           \
                                        )                                                                                               \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                   CALS(Ifausses_couleurs_BVR_888_universel(image_en_vraies_couleurs                                    \
                                                                           ,image_ROUGE,image_VERTE,image_BLEUE                         \
                                                                            )                                                           \
                                        );                                                                                              \
                                        /* Et 'multiplexage universel' des trois images Arguments.                                   */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   CALS(Iajustement_de_la_luminance_BVR_888(image_en_vraies_couleurs                                    \
                                                                           ,image_ROUGE,image_VERTE,image_BLEUE                         \
                                                                           ,minimum_de_la_luminance                                     \
                                                                           ,maximum_de_la_luminance                                     \
                                                                            )                                                           \
                                        );                                                                                              \
                                        /* Et 'multiplexage universel' des trois images Arguments, avec re-ajustement de la          */ \
                                        /* luminance sauf pour les points 'NOIR'...                                                  */ \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                                        /* Conversion d'une image au format attendu...                                               */
#    Aifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
#    Eifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL

#    ifdef     __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#         define    GET_ARGUMENTSi_X_WINDOW                                                                                             \
                              Bblock                                                                                                    \
                                                                                                                                        \
                              DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES;                                           \
                                        /* Introduit le 20070130102731 car, en effet, il manquait...                                 */ \
                                                                                                                                        \
                              GET_ARGUMENT_L("editer=""XY_curseur=""XY=",X11_____KeyPress_____editer_XY_curseur);                       \
                              GET_ARGUMENT_L("normaliser_XY_curseur=""NXY=",X11_____KeyPress_____norm_XY_curseur);                      \
                              GET_ARGUMENT_F("OX_curseur=""OX=",X11_____KeyPress_____OX_curseur);                                       \
                              GET_ARGUMENT_F("LX_curseur=""LX=",X11_____KeyPress_____LX_curseur);                                       \
                              GET_ARGUMENT_F("OY_curseur=""OY=",X11_____KeyPress_____OY_curseur);                                       \
                              GET_ARGUMENT_F("LY_curseur=""LY=",X11_____KeyPress_____LY_curseur);                                       \
                                                                                                                                        \
                              GET_ARGUMENT_L("SGIattention=",SGI_____editer_les_PRINT_ATTENTION_initiaux);                              \
                                                                                                                                        \
                              FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES;                                           \
                                        /* Introduit le 20070130102731 car, en effet, il manquait...                                 */ \
                                                                                                                                        \
                              Eblock                                                                                                    \
                                        /* Pour entrer les arguments specifiques 'X-Window'...                                       */

#         define    CONVERSION_D_UNE_IMAGE_QUELCONQUE(image_ROUGE,image_VERTE,image_BLEUE)                                              \
                              Bblock                                                                                                    \
                              Test(IFET(IFEQ(minimum_de_la_luminance,MINIMUM_DE_LA_LUMINANCE)                                           \
                                       ,IFEQ(maximum_de_la_luminance,MAXIMUM_DE_LA_LUMINANCE)                                           \
                                        )                                                                                               \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                   CALS(Ifausses_couleurs_RVBg_888_universel(image_en_vraies_couleurs                                   \
                                                                            ,image_ROUGE,image_VERTE,image_BLEUE                        \
                                                                             )                                                          \
                                        );                                                                                              \
                                        /* Et 'multiplexage universel' des trois images Arguments.                                   */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   CALS(Iajustement_de_la_luminance_RVBg_888(image_en_vraies_couleurs                                   \
                                                                            ,image_ROUGE,image_VERTE,image_BLEUE                        \
                                                                            ,minimum_de_la_luminance                                    \
                                                                            ,maximum_de_la_luminance                                    \
                                                                             )                                                          \
                                        );                                                                                              \
                                        /* Et 'multiplexage universel' des trois images Arguments, avec re-ajustement de la          */ \
                                        /* luminance sauf pour les points 'NOIR'...                                                  */ \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                                        /* Conversion d'une image au format attendu...                                               */
#    Aifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#    Eifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL

#    define    CONVERSION_D_UNE_IMAGE                                                                                                   \
                         Bblock                                                                                                         \
                         CONVERSION_D_UNE_IMAGE_QUELCONQUE(Image_ROUGE,Image_VERTE,Image_BLEUE);                                        \
                         Eblock                                                                                                         \
                                        /* Conversion d'une image au format attendu...                                               */

#    define    AFFICHAGE_D_UNE_IMAGE_ET_ATTENTE(attendre)                                                                               \
                         Bblock                                                                                                         \
                         CALS(IGdisplay(image_en_vraies_couleurs                                                                        \
                                       ,facteur_de_zoom                                                                                 \
                                       ,centrer_l_image_dans_la_fenetre                                                                 \
                                       ,ADRESSE(translation_de_l_image_dans_la_fenetre)                                                 \
                                        )                                                                                               \
                              );                                                                                                        \
                                        /* Affichage de l'image.                                                                     */ \
                                                                                                                                        \
                         Test(IL_FAUT(attendre))                                                                                        \
                              Bblock                                                                                                    \
                              Test(IL_FAUT(synchronisation_externe))                                                                    \
                                   Bblock                                                                                               \
                                   DODO(duree_d_attente);                                                                               \
                                        /* On attend d'abord un petit peu et ce pour des raisons liees au probleme du repos          */ \
                                        /* d'ecran, car on ne sait pas vraiment combien de temps dure le retour a la normale...      */ \
                                   MISE_DU_FEU_AU_VERT(FEU_DE_SYNCHRONISATION_DE_FIN_D_AFFICHAGE_D_IMAGE);                              \
                                        /* On indique ainsi que l'image est surement visible, et que l'on peut par exemple           */ \
                                        /* l'enregistrer...                                                                          */ \
                                   ATTENDRE_AU_FEU_ROUGE(FEU_DE_SYNCHRONISATION_DE_FIN_DES_ENREGISTREMENTS_PAL_BETA);                   \
                                        /* Attente de synchronisation externe (par exemple une fin d'enregistrement video...).       */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Test(IZEQ(duree_d_attente))                                                                          \
                                        Bblock                                                                                          \
                                        CALS(IGattente_de_l_evenement_ButtonPress());                                                   \
                                        /* Lorsque la duree d'attente est nulle, l'attente se fait a l'aide de l'un des trois        */ \
                                        /* bouton de la souris...                                                                    */ \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        DODO(duree_d_attente);                                                                          \
                                        /* Attente implicite lorsqu'il n'y a pas de synchronisation externe...                       */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                                        /* Affichage d'une image et attente...                                                       */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

#TestADef GET_ARGUMENTSi_X_WINDOW                                                                                                       \
                    Bblock                                                                                                              \
                                                                                                                                        \
                    DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES;                                                     \
                                        /* Introduit le 20070130102731 car, en effet, il manquait...                                 */ \
                                                                                                                                        \
                    BLOC(VIDE;);                                                                                                        \
                                                                                                                                        \
                    FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES;                                                     \
                                        /* Introduit le 20070130102731 car, en effet, il manquait...                                 */ \
                                                                                                                                        \
                    Eblock                                                                                                              \
                                        /* Pour entrer les arguments specifiques 'X-Window'...                                       */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I S P L A Y   D ' U N E   I M A G E   D A N S   U N E   F E N E T R E   2 D  :                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
     DEFV(Logical,INIT(centrer_la_fenetre,CENTRER_LA_FENETRE));
                                        /* Faut-il centrer la fenetre ('VRAI') ou pas ('FAUX').                                      */
     DEFV(Logical,INIT(corriger_le_gamma,CORRIGER_LE_GAMMA));
                                        /* A priori, on ne touchera pas a la correction de gamma.                                    */
     DEFV(Float,INIT(correction_de_gamma_ROUGE,CORRECTION_DE_GAMMA_ROUGE));
     DEFV(Float,INIT(correction_de_gamma_VERTE,CORRECTION_DE_GAMMA_VERTE));
     DEFV(Float,INIT(correction_de_gamma_BLEUE,CORRECTION_DE_GAMMA_BLEUE));
                                        /* Corrections de gamma implicites.                                                          */

     DEFV(CHAR,INIC(POINTERc(nom_imageAR),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageAV),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageAB),NOM_PIPE));
                                        /* Nom de l'image en vraies couleurs a displayer.                                            */

     DEFV(CHAR,INIC(POINTERc(nom_de_la_fenetre),NOM_DE_LA_FENETRE));
                                        /* Nom de la fenetre...                                                                      */
     DEFV(Logical,INIT(generer_de_la_video,GENERER_DE_LA_VIDEO));
                                        /* De la video "standard" 780x575 ('VRAI') ou de la "haute-definition" 1280x1024 ('FAUX').   */
     DEFV(Logical,INIT(laisser_le_curseur_apparaitre_pendant_l_affichage,LAISSER_LE_CURSEUR_APPARAITRE_PENDANT_L_AFFICHAGE));
                                        /* Indicateur precisant s'il faut laisser le curseur de l'ecran pendant que cette fenetre    */
                                        /* est ouverte ('VRAI') ou le supprimer ('FAUX').                                            */
     DEFV(Logical,INIT(redimensionner_les_images_RVB,REDIMENSIONNER_LES_IMAGES_RVB));
                                        /* Les images 'RVB' doivent-elles etre redimensionnees ('VRAI') ou pas ('FAUX').             */
     DEFV(Int,INIT(methode_de_redimensionnement_a_utiliser,METHODE_DE_REECHANTILLONNAGE_A_UTILISER));
                                        /* Methode de redimensionnement a utiliser alors...                                          */
     DEFV(Logical,INIT(conserver_les_proportions_lors_d_un_redimensionnement,CONSERVER_LES_PROPORTIONS_LORS_D_UN_REDIMENSIONNEMENT));
                                        /* Faut-il conserver ('VRAI') ou pas ('FAUX') les proportions de l'image Argument. La        */
                                        /* valeur implicite ('FAUX') permet d'occuper tout l'ecran, et ce quelle que soit l'image    */
                                        /* Argument...                                                                               */
     DEFV(Float,INIT(translation_OX_de_la_fenetre,TRANSLATION_OX_DE_LA_FENETRE));
     DEFV(Float,INIT(translation_OY_de_la_fenetre,TRANSLATION_OY_DE_LA_FENETRE));
                                        /* Argument de translation de la fenetre.                                                    */
     DEFV(deltaF_2D,translation_de_la_fenetre);
                                        /* Translation de la fenetre.                                                                */
     DEFV(Logical,INIT(centrer_l_image_dans_la_fenetre,CENTRER_L_IMAGE_DANS_LA_FENETRE));
                                        /* Centrer ou pas (il faut alors la translation suivante) l'image dans la fenetre...         */
     DEFV(Float,INIT(translation_OX_de_l_image_dans_la_fenetre,TRANSLATION_OX_DE_L_IMAGE_DANS_LA_FENETRE));
     DEFV(Float,INIT(translation_OY_de_l_image_dans_la_fenetre,TRANSLATION_OY_DE_L_IMAGE_DANS_LA_FENETRE));
                                        /* Argument de translation de l'image dans la fenetre.                                       */
     DEFV(deltaF_2D,translation_de_l_image_dans_la_fenetre);
                                        /* Translation de l'image dans la fenetre.                                                   */
     DEFV(Float,INIT(facteur_de_zoom,FACTEUR_DE_ZOOM));
                                        /* Facteur de zoom de l'image.                                                               */
     DEFV(genere_p,INIT(minimum_de_la_luminance,MINIMUM_DE_LA_LUMINANCE));
     DEFV(genere_p,INIT(maximum_de_la_luminance,MAXIMUM_DE_LA_LUMINANCE));
                                        /* Minimum et maximum demande pour chaque point (a l'exception des points 'NOIR').           */
     DEFV(Logical,INIT(synchronisation_externe,SYNCHRONISATION_EXTERNE));
                                        /* Indique s'il y a une attente implicite par 'DUREE_D_ATTENTE' ('FAUX') ou bien une         */
                                        /* synchronisation sur un signal externe par 'ATTENDRE_AU_FEU_ROUGE' ('VRAI').               */
     DEFV(Int,INIT(duree_d_attente,DUREE_D_ATTENTE));
                                        /* Duree d'attente apres l'affichage d'une image et avant son effacement.                    */
                                        /*                                                                                           */
                                        /* ATTENTION, jusqu'au 19970507160714, cet 'Int' avait le type 'Positive'.                   */

     DEFV(Logical,INIT(entree_video_temps_reel,ENTREE_VIDEO_TEMPS_REEL));
                                        /* De la video va-t-elle etre entree ('VRAI') ou pas ('FAUX')...                             */
                                        /*                                                                                           */
                                        /* ATTENTION, la definition de l'indicateur 'entree_video_temps_reel' ne doit pas etre       */
                                        /* conditionne par 'L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE' car il est teste une fois        */
                                        /* en dehors des compilations conditionnelles...                                             */
     DEFV(CHAR,INIC(POINTERc(nom_imageRR),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageRV),NOM_PIPE));
     DEFV(CHAR,INIC(POINTERc(nom_imageRB),NOM_PIPE));
                                        /* Nom de l'image en vraies couleurs numerisee.                                              */

#    ifdef     L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
     DEFV(CHAR,INIC(POINTERc(serveur_standard),SERVEUR_STANDARD));
                                        /* Le serveur standard est celui qui est defini par la variable "DISPLAY".                   */
     DEFV(Logical,INIT(editer_les_PRINT_ATTENTION_initiaux,EDITER_LES_PRINT_ATTENTION_INITIAUX));
                                        /* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis         */
                                        /* ('VRAI') ou pas ('FAUX').                                                                 */
     DEFV(Logical,INIT(numeriser_une_image,NUMERISER_UNE_IMAGE));
                                        /* Si de la video entre, faut-il numeriser une image ('VRAI') ou pas ('FAUX')...             */
     DEFV(Logical,INIT(centrer_la_fenetre_video_temps_reel,CENTRER_LA_FENETRE_VIDEO_TEMPS_REEL));
                                        /* Faut-il centrer la fenetre video temps reel ('VRAI') ou bien donner explicitement la      */
                                        /* position de son coin "bas gauche" ('FAUX') ?                                              */
     DEFV(pointF_2D,coin_bas_gauche);
                                        /* Position du coin bas gauche de la fenetre.                                                */
#    Aifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
#    Eifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

     /*..............................................................................................................................*/

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

#    ifdef     L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
     INITIALISATION_POINT_2D(coin_bas_gauche
                            ,_____cNORMALISE_OX11(X_COIN_BAS_GAUCHE)
                            ,_____cNORMALISE_OY11(Y_COIN_BAS_GAUCHE)
                             );
                                        /* Definition de la position implicite de la fenetre.                                        */
     EGAL(X11_____signaler_les_evenements_inattendus,SIGNALER_LES_EVENEMENTS_INATTENDUS);
                                        /* Initialisation du signalisateur d'evenement inattendu...                                  */

#         ifdef     BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageAR=""AR=",nom_imageAR);
                         GET_ARGUMENT_C("imageAV=""AV=",nom_imageAV);
                         GET_ARGUMENT_C("imageAB=""AB=",nom_imageAB);
                         GET_ARGUMENT_C("titre=""nom=""fenetre=",nom_de_la_fenetre);
                         GET_ARGUMENT_L("synchronisation=""sync=""s=",synchronisation_externe);

                         ENTREE_DES_ARGUMENTS_DE_L_ENTREE_VIDEO_TEMPS_REEL;

                         GET_ARGUMENT_I("duree=""d=",duree_d_attente);
                         GET_ARGUMENT_I("xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("xM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("XM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("yM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("YM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_L("Fcentrer=""Fc=",centrer_la_fenetre);
                                        /* Parametre introduit le 20060427162244...                                                  */
                         GET_ARGUMENT_L("gamma=",corriger_le_gamma);
                         GET_ARGUMENT_F("gamma_ROUGE=""gROUGE=",correction_de_gamma_ROUGE);
                         GET_ARGUMENT_F("gamma_VERTE=""gVERTE=",correction_de_gamma_VERTE);
                         GET_ARGUMENT_F("gamma_BLEUE=""gBLEUE=",correction_de_gamma_BLEUE);
                         GET_ARGUMENT_F("trx=""trX=",translation_OX_de_la_fenetre);
                         GET_ARGUMENT_F("try=""trY=",translation_OY_de_la_fenetre);
                         GET_ARGUMENT_L("centrer=",centrer_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tix=""tiX=",translation_OX_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tiy=""tiY=",translation_OY_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("zoom=",facteur_de_zoom);
                         GET_ARGUMENT_P("minimum=",minimum_de_la_luminance);
                         GET_ARGUMENT_P("maximum=",maximum_de_la_luminance);
                         GET_ARGUMENT_L("video=",generer_de_la_video);
                         GET_ARGUMENT_L("X_Window=",SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL);
                         GET_ARGUMENT_L("curseur=",laisser_le_curseur_apparaitre_pendant_l_affichage);
                         GET_ARGUMENT_L("redimensionner=",redimensionner_les_images_RVB);
                         GET_ARGUMENT_I("methode=",methode_de_redimensionnement_a_utiliser);
                         GET_ARGUMENT_P("niveau=",REECHANTILLONNAGE_GENERAL_____niveau_manquant);
                         GET_ARGUMENT_L("proportions=""proportion=",conserver_les_proportions_lors_d_un_redimensionnement);
                         GET_ARGUMENT_L("entree=",entree_video_temps_reel);
                         GET_ARGUMENT_L("numeriser=",numeriser_une_image);
                         GET_ARGUMENT_I("mode=",SGI_____mode_de_numerisation_des_images);
                         GET_ARGUMENT_I("ignorer=",SGI_____nombre_d_images_a_ignorer_avant_d_en_numeriser_une);
                         GET_ARGUMENT_C("imageRR=""RR=",nom_imageRR);
                         GET_ARGUMENT_C("imageRV=""RV=",nom_imageRV);
                         GET_ARGUMENT_C("imageRB=""RB=",nom_imageRB);
                         GET_ARGUMENT_L("Vcentrer=",centrer_la_fenetre_video_temps_reel);
                         GET_ARGUMENT_I("pal=",SGI_____Gentree_video_utilisee);
                         GET_ARGUMENT_I("bandeau=",SGI_____facteur_de_reduction_verticale_d_une_fenetre_bandeau);
                         GET_ARGUMENT_I("repos=",SGI_____Gentree_video_de_repos);
                         GET_ARGUMENT_I("d2x=""d2X=",SGI_____fenetre_X_WINDOW_decalage_2_video_X);
                         GET_ARGUMENT_I("d2y=""d2Y=",SGI_____fenetre_X_WINDOW_decalage_2_video_Y);
                         GET_ARGUMENT_I("zoomN=""Nz=",SGI_____numerateur_du_rapport_de_zoom);
                         GET_ARGUMENT_I("zoomD=""Dz=",SGI_____denominateur_du_rapport_de_zoom);
                         GET_ARGUMENT_C("serveur=",serveur_standard);
                         GET_ARGUMENT_L("ne_pas_verifier_le_serveur=""npvs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                         GET_ARGUMENT_N("verifier_le_serveur=""vs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                                        /* Arguments introduits le 20100109112528 pour acceder au serveur 'Xming' (Windows Vista).   */
                         GET_ARGUMENT_L("attention=",editer_les_PRINT_ATTENTION_initiaux);
                         GET_ARGUMENT_L("signaler=",X11_____signaler_les_evenements_inattendus);
                         GET_ARGUMENT_L("trop_grandes=""trop_grande="
                                       ,X11_____tenter_l_ouverture_des_fenetres_trop_grandes_par_rapport_a_l_ecran
                                        );
                         GET_ARGUMENTSi_X_WINDOW;
                         GET_ARGUMENT_F("xc=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("x=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("X=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("yc=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_F("y=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_F("Y=",ASD1(coin_bas_gauche,y));
                         )
                    );
#         Aifdef    BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageAR=""AR=",nom_imageAR);
                         GET_ARGUMENT_C("imageAV=""AV=",nom_imageAV);
                         GET_ARGUMENT_C("imageAB=""AB=",nom_imageAB);
                         GET_ARGUMENT_C("titre=""nom=""fenetre=",nom_de_la_fenetre);
                         GET_ARGUMENT_L("synchronisation=""sync=""s=",synchronisation_externe);

                         ENTREE_DES_ARGUMENTS_DE_L_ENTREE_VIDEO_TEMPS_REEL;

                         GET_ARGUMENT_I("duree=""d=",duree_d_attente);
                         GET_ARGUMENT_I("xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("xM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("XM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("yM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("YM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_L("Fcentrer=""Fc=",centrer_la_fenetre);
                                        /* Parametre introduit le 20060427162244...                                                  */
                         GET_ARGUMENT_L("gamma=",corriger_le_gamma);
                         GET_ARGUMENT_F("gamma_ROUGE=""gROUGE=",correction_de_gamma_ROUGE);
                         GET_ARGUMENT_F("gamma_VERTE=""gVERTE=",correction_de_gamma_VERTE);
                         GET_ARGUMENT_F("gamma_BLEUE=""gBLEUE=",correction_de_gamma_BLEUE);
                         GET_ARGUMENT_F("trx=""trX=",translation_OX_de_la_fenetre);
                         GET_ARGUMENT_F("try=""trY=",translation_OY_de_la_fenetre);
                         GET_ARGUMENT_L("centrer=",centrer_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tix=""tiX=",translation_OX_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tiy=""tiY=",translation_OY_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("zoom=",facteur_de_zoom);
                         GET_ARGUMENT_P("minimum=",minimum_de_la_luminance);
                         GET_ARGUMENT_P("maximum=",maximum_de_la_luminance);
                         GET_ARGUMENT_L("video=",generer_de_la_video);
                         GET_ARGUMENT_L("X_Window=",SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL);
                         GET_ARGUMENT_L("curseur=",laisser_le_curseur_apparaitre_pendant_l_affichage);
                         GET_ARGUMENT_L("redimensionner=",redimensionner_les_images_RVB);
                         GET_ARGUMENT_I("methode=",methode_de_redimensionnement_a_utiliser);
                         GET_ARGUMENT_P("niveau=",REECHANTILLONNAGE_GENERAL_____niveau_manquant);
                         GET_ARGUMENT_L("proportions=""proportion=",conserver_les_proportions_lors_d_un_redimensionnement);
                         GET_ARGUMENT_L("entree=",entree_video_temps_reel);
                         GET_ARGUMENT_L("numeriser=",numeriser_une_image);
                         GET_ARGUMENT_I("mode=",SGI_____mode_de_numerisation_des_images);
                         GET_ARGUMENT_I("ignorer=",SGI_____nombre_d_images_a_ignorer_avant_d_en_numeriser_une);
                         GET_ARGUMENT_C("imageRR=""RR=",nom_imageRR);
                         GET_ARGUMENT_C("imageRV=""RV=",nom_imageRV);
                         GET_ARGUMENT_C("imageRB=""RB=",nom_imageRB);
                         GET_ARGUMENT_L("Vcentrer=",centrer_la_fenetre_video_temps_reel);
                         GET_ARGUMENT_I("pal=",SGI_____Gentree_video_utilisee);
                         GET_ARGUMENT_I("bandeau=",SGI_____facteur_de_reduction_verticale_d_une_fenetre_bandeau);
                         GET_ARGUMENT_I("d2x=""d2X=",SGI_____fenetre_X_WINDOW_decalage_2_video_X);
                         GET_ARGUMENT_I("d2y=""d2Y=",SGI_____fenetre_X_WINDOW_decalage_2_video_Y);
                         GET_ARGUMENT_I("zoomN=""Nz=",SGI_____numerateur_du_rapport_de_zoom);
                         GET_ARGUMENT_I("zoomD=""Dz=",SGI_____denominateur_du_rapport_de_zoom);
                         GET_ARGUMENT_C("serveur=",serveur_standard);
                         GET_ARGUMENT_L("ne_pas_verifier_le_serveur=""npvs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                         GET_ARGUMENT_N("verifier_le_serveur=""vs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                                        /* Arguments introduits le 20100109112528 pour acceder au serveur 'Xming' (Windows Vista).   */
                         GET_ARGUMENT_L("attention=",editer_les_PRINT_ATTENTION_initiaux);
                         GET_ARGUMENT_L("signaler=",X11_____signaler_les_evenements_inattendus);
                         GET_ARGUMENTSi_X_WINDOW;
                         GET_ARGUMENT_F("xc=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("x=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("X=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("yc=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_F("y=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_F("Y=",ASD1(coin_bas_gauche,y));
                         )
                    );
#         Eifdef    BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL

#    Aifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageAR=""AR=",nom_imageAR);
                         GET_ARGUMENT_C("imageAV=""AV=",nom_imageAV);
                         GET_ARGUMENT_C("imageAB=""AB=",nom_imageAB);
                         GET_ARGUMENT_C("titre=""nom=""fenetre=",nom_de_la_fenetre);
                         GET_ARGUMENT_L("synchronisation=""sync=""s=",synchronisation_externe);

                         ENTREE_DES_ARGUMENTS_DE_L_ENTREE_VIDEO_TEMPS_REEL;

                         GET_ARGUMENT_I("duree=""d=",duree_d_attente);
                         GET_ARGUMENT_I("xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("xM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Xm=",SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("XM=",SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("yM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("Ym=",SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_I("YM=",SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION);
                         GET_ARGUMENT_L("Fcentrer=""Fc=",centrer_la_fenetre);
                                        /* Parametre introduit le 20060427162244...                                                  */
                         GET_ARGUMENT_L("gamma=",corriger_le_gamma);
                         GET_ARGUMENT_F("gamma_ROUGE=""gROUGE=",correction_de_gamma_ROUGE);
                         GET_ARGUMENT_F("gamma_VERTE=""gVERTE=",correction_de_gamma_VERTE);
                         GET_ARGUMENT_F("gamma_BLEUE=""gBLEUE=",correction_de_gamma_BLEUE);
                         GET_ARGUMENT_F("trx=""trX=",translation_OX_de_la_fenetre);
                         GET_ARGUMENT_F("try=""trY=",translation_OY_de_la_fenetre);
                         GET_ARGUMENT_L("centrer=",centrer_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tix=""tiX=",translation_OX_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("tiy=""tiY=",translation_OY_de_l_image_dans_la_fenetre);
                         GET_ARGUMENT_F("zoom=",facteur_de_zoom);
                         GET_ARGUMENT_P("minimum=",minimum_de_la_luminance);
                         GET_ARGUMENT_P("maximum=",maximum_de_la_luminance);
                         GET_ARGUMENT_L("video=",generer_de_la_video);
                         GET_ARGUMENT_L("X_Window=",SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL);
                         GET_ARGUMENT_L("curseur=",laisser_le_curseur_apparaitre_pendant_l_affichage);
                         GET_ARGUMENT_L("redimensionner=",redimensionner_les_images_RVB);
                         GET_ARGUMENT_I("methode=",methode_de_redimensionnement_a_utiliser);
                         GET_ARGUMENT_P("niveau=",REECHANTILLONNAGE_GENERAL_____niveau_manquant);
                         GET_ARGUMENT_L("proportions=""proportion=",conserver_les_proportions_lors_d_un_redimensionnement);
                         GET_ARGUMENT_L("signaler=",X11_____signaler_les_evenements_inattendus);
                         GET_ARGUMENTSi_X_WINDOW;
                         )
                    );
#    Eifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(VIDE;
                         )
                    );
                                        /* Introduit le 20070301174222...                                                            */

     PRINT_ATTENTION("aucun imageur n'est accessible");
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
     INITIALISATION_ACCROISSEMENT_2D(translation_de_la_fenetre
                                    ,translation_OX_de_la_fenetre
                                    ,translation_OY_de_la_fenetre
                                     );
                                        /* Mise en place de la translation de la fenetre.                                            */
     INITIALISATION_ACCROISSEMENT_2D(translation_de_l_image_dans_la_fenetre
                                    ,translation_OX_de_l_image_dans_la_fenetre
                                    ,translation_OY_de_l_image_dans_la_fenetre
                                     );
                                        /* Mise en place de la translation de la fenetre.                                            */

     Test(IL_NE_FAUT_PAS(entree_video_temps_reel))
          Bblock
          Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_ROUGE,nom_imageAR))))
               Bblock
                                        /* Chargement de la premiere image Argument.                                                 */
               Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_VERTE,nom_imageAV))))
                    Bblock
                                        /* Chargement de la deuxieme image Argument.                                                 */
                    Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_BLEUE,nom_imageAB))))
                         Bblock
                                        /* Chargement de la troisieme image Argument.                                                */
                         Test(IFOU(IL_NE_FAUT_PAS(redimensionner_les_images_RVB)
                                  ,IFET(IFET(IFEQ(Xmin,XminPali),IFEQ(Xmax,XmaxPali))
                                       ,IFET(IFEQ(Ymin,YminPali),IFEQ(Ymax,YmaxPali))
                                        )
                                   )
                              )
                              Bblock
                              BDEFV(imageU,image_en_vraies_couleurs);
                                        /* Image en vraies couleurs au format 'Silicon-Graphics'.                                    */

                              CONVERSION_D_UNE_IMAGE;
                              OUVERTURE_DE_LA_FENETRE;
                              AFFICHAGE_D_UNE_IMAGE_ET_ATTENTE(VRAI);
                              FERMETURE_DE_LA_FENETRE;
                                        /* Affichage de l'image et attente...                                                        */

                              EDEFV(imageU,image_en_vraies_couleurs);
                                        /* Image en vraies couleurs au format 'Silicon-Graphics'.                                    */
                              Eblock
                         ATes
                              Bblock
                              DEFV(Int,INIT(XminRedim,XminPali));
                              DEFV(Int,INIT(XmaxRedim,XmaxPali));
                              DEFV(Int,INIT(YminRedim,YminPali));
                              DEFV(Int,INIT(YmaxRedim,YmaxPali));
                                        /* Dimensions de l'image apres redimensionnement (a priori, format 'Pal' sans respecter      */
                                        /* les proportions...).                                                                      */

                              PUSH_DIMENSIONS_2D;

                              Test(IL_FAUT(conserver_les_proportions_lors_d_un_redimensionnement))
                                   Bblock
                                   DEFV(Float,INIT(rapport_X
                                                  ,DIVI(FLOT(SOUS(XmaxPali,XminPali))
                                                       ,FLOT(SOUS(EnTete_de_sauvegardM ## Xmax,EnTete_de_sauvegardM ## Xmin))
                                                        )
                                                   )
                                        );
                                        /* Calcul du rapport "horizontal",                                                           */
                                   DEFV(Float,INIT(rapport_Y
                                                  ,DIVI(FLOT(SOUS(YmaxPali,YminPali))
                                                       ,FLOT(SOUS(EnTete_de_sauvegardM ## Ymax,EnTete_de_sauvegardM ## Ymin))
                                                        )
                                                   )
                                        );
                                        /* Calcul du rapport "vertical",                                                             */
                                   DEFV(Float,INIT(rapport_XY,FLOT__UNDEF));
                                        /* Definition des trois rapports necessaires a garder les proportions de l'image Argument.   */

                                   EGAL(rapport_XY,MIN2(rapport_X,rapport_Y));
                                        /* Et enfin du plus petit rapport des deux qui garantit que l'une au moins des deux          */
                                        /* dimensions de l'image Argument va occuper entierement la dimension correspondante         */
                                        /* de la video...                                                                            */

                                   EGAL(XminRedim,XminPali);
                                   EGAL(XmaxRedim
                                       ,ADD2(INTE(MUL2(rapport_XY,SOUS(EnTete_de_sauvegardM ## Xmax,EnTete_de_sauvegardM ## Xmin)))
                                            ,XminPali
                                             )
                                        );

                                   EGAL(YminRedim,YminPali);
                                   EGAL(YmaxRedim
                                       ,ADD2(INTE(MUL2(rapport_XY,SOUS(EnTete_de_sauvegardM ## Ymax,EnTete_de_sauvegardM ## Ymin)))
                                            ,YminPali
                                             )
                                        );
                                   Eblock
                              ATes
                                   Bblock
                                   Eblock
                              ETes

                              SET_DIMENSIONS_2D_SANS_VALIDATION(XminRedim,XmaxRedim,YminRedim,YmaxRedim);
                                        /* Mise en place du format 'Pal' lorsque les proportions ne sont pas conservees, ou d'un     */
                                        /* format reduit lorsqu'il faut conserver les proportions...                                 */

                              begin_nouveau_block
                                   Bblock
                                        /* ATTENTION, l'ouverture de ce nouveau bloc {Bblock,Eblock} est destinee uniquement a       */
                                        /* permettre la definition des images qui suivent par 'BDEFV(...)' maintenant que l'on       */
                                        /* connait (grace a 'SET_DIMENSIONS_2D_SANS_VALIDATION(...)') leur taille reelle...          */
                                   BDEFV(image,image_ROUGE);
                                   BDEFV(image,image_VERTE);
                                   BDEFV(image,image_BLEUE);
                                        /* Image en vraies couleurs Argument redimensionnees.                                        */
                                   BDEFV(imageU,image_en_vraies_couleurs);
                                        /* Image en vraies couleurs au format 'Silicon-Graphics'.                                    */

                                   REDIMENSIONNEMENT(image_ROUGE,Image_ROUGE);
                                   REDIMENSIONNEMENT(image_VERTE,Image_VERTE);
                                   REDIMENSIONNEMENT(image_BLEUE,Image_BLEUE);

                                   CONVERSION_D_UNE_IMAGE_QUELCONQUE(image_ROUGE,image_VERTE,image_BLEUE);
                                   OUVERTURE_DE_LA_FENETRE;
                                   AFFICHAGE_D_UNE_IMAGE_ET_ATTENTE(VRAI);
                                   FERMETURE_DE_LA_FENETRE;
                                        /* Affichage de l'image et attente...                                                        */

                                   EDEFV(imageU,image_en_vraies_couleurs);
                                        /* Image en vraies couleurs au format 'Silicon-Graphics'.                                    */
                                   EDEFV(image,image_BLEUE);
                                   EDEFV(image,image_VERTE);
                                   EDEFV(image,image_ROUGE);
                                        /* Image en vraies couleurs Argument redimensionnees.                                        */
                                   Eblock
                              end_nouveau_block

                              PULL_DIMENSIONS_2D;
                              Eblock
                         ETes
                         Eblock
                    ATes
                         Bblock
                         Test__CODE_ERREUR__ERREUR07;
                         Eblock
                    ETes
                    Eblock
               ATes
                    Bblock
                    Test__CODE_ERREUR__ERREUR07;
                    Eblock
               ETes
               Eblock
          ATes
               Bblock
               Test__CODE_ERREUR__ERREUR07;
               Eblock
          ETes
          Eblock
     ATes
          Bblock

#    ifdef     L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
          Test(IL_FAUT(numeriser_une_image))
               Bblock
               CALS(IGdebut_de_numerisation_d_une_image_video());
                                        /* Debut de la numerisation d'une image video...                                             */
               CALS(IGfin_de_numerisation_d_une_image_video(Image_ROUGE
                                                           ,Image_VERTE
                                                           ,Image_BLEUE
                                                           ,methode_de_redimensionnement_a_utiliser
                                                            )
                    );
                                        /* Fin de la numerisation d'une image video...                                               */

               CALi(Iupdate_image(nom_imageRR,Image_ROUGE));
               CALi(Iupdate_image(nom_imageRV,Image_VERTE));
               CALi(Iupdate_image(nom_imageRB,Image_BLEUE));
                                        /* Et archivage de l'image numerisee.                                                        */
               Eblock
          ATes
               Bblock
               CALS(IGdebut_de_diffusion_d_une_sequence_video_temps_reel(serveur_standard
                                                                        ,nom_de_la_fenetre
                                                                        ,centrer_la_fenetre_video_temps_reel
                                                                        ,ADRESSE(coin_bas_gauche)
                                                                        ,editer_les_PRINT_ATTENTION_initiaux
                                                                         )
                    );
                                        /* Debut de la sequence video temps reel...                                                  */

               Test(IZEQ(duree_d_attente))
                    Bblock
                    CALS(IXattente_de_l_evenement_ButtonPress());
                                        /* Cas d'une attente indefinie...                                                            */
                    Eblock
               ATes
                    Bblock
                    DODO(duree_d_attente);
                                        /* Cas d'une attente programmee...                                                           */
                    Eblock
               ETes

               CALS(IGfin_de_diffusion_d_une_sequence_video_temps_reel());
                                        /* Fin de la sequence video temps reel...                                                    */
               Eblock
          ETes
#    Aifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE
          PRINT_ATTENTION("l'entree video temps reel n'est pas disponible sur cette machine");
#    Eifdef    L_ENTREE_VIDEO_TEMPS_REEL_EST_POSSIBLE

          Eblock
     ETes
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.