/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T R A C E   D U   S P E C T R E  :                                                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                    Definition du polygone "Spectre" (en notant une                                                                */
/*                  symetrie d'axe OY par rapport a 'v $xrd/spectre.01$K') :                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                                     C                                                                             */
/*                                                     #---------.                                                                   */
/*                                                    /    08    |                                                                   */
/*                                                   /           |                                                                   */
/*                                                  / 09      07 |                                                                   */
/*                                                 /             |                                                                   */
/*                                                .              .                                                                   */
/*                                               /                \                                                                  */
/*                                              /                  \                                                                 */
/*                                             / 10              06 \                                                                */
/*                                            /                      \                                                               */
/*                                           .                        .                                                              */
/*                                            \                      /                                                               */
/*                                             \ 11              05 /                                                                */
/*                                              \                  /                                                                 */
/*                                               \                /                                                                  */
/*                                                .              .                                                                   */
/*                                              /                 \                                                                  */
/*                                            /                 04 \                                                                 */
/*                                          /  12                   \                                                                */
/*                                      D /                          .                                                               */
/*                                      #               /\      03 /                                                                 */
/*                                      |              /  \ 02   /                                                                   */
/*                                      | 13       01 /    \   /                                                                     */
/*                                      |            /      \#                                                                       */
/*                                      |           /        B                                                                       */
/*                                      |    00    /                                                                                 */
/*                                       ---------#                                                                                  */
/*                                                A                                                                                  */
/*                                                                                                                                   */
/*                                                     .---------.                                                                   */
/*                                                    /    28    |                                                                   */
/*                                                   /           |                                                                   */
/*                                                  / 29      27 |                                                                   */
/*                                                 /             |                                                                   */
/*                                                .              .                                                                   */
/*                                               /                \                                                                  */
/*                                              /                  \                                                                 */
/*                                             / 30              26 \                                                                */
/*                                            /                      \                                                               */
/*                                           .                        .                                                              */
/*                                            \                      /                                                               */
/*                                             \ 31              25 /                                                                */
/*                                              \                  /                                                                 */
/*                                               \                /                                                                  */
/*                                                .              .                                                                   */
/*                                              /                 \                                                                  */
/*                                            /                 24 \                                                                 */
/*                                          /  32                   \                                                                */
/*                                        /                          .                                                               */
/*                                      .               /\      23 /                                                                 */
/*                                      |              /  \ 22   /                                                                   */
/*                                      | 33       21 /    \   /                                                                     */
/*                                      |            /      \/                                                                       */
/*                                      |           /                                                                                */
/*                                      |    20    /                                                                                 */
/*                                       ---------                                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  Les numeros correspondent aux numeros des Contextes Graphiques                                                   */
/*                  contenant l'ORIGINE de chaque segment definissant a un cote                                                      */
/*                  et les lettres {A,B,C,D,A} au "squelette" du "Spectre"...                                                        */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrd/spectre.12$K' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20230907091626).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NO_DEFINE_____premiers_entiers_naturels
                                        /* Et ce a cause des collisions avec 'nom_des_CONTEXTES_0' ci-apres...                       */

#include  INCLUDES_BASE
#include  image_image_CONTOURS_EXT
#include  image_image_ALPHABET_0_EXT
#include  image_image_ALPHABET_1_EXT
#include  image_image_ALPHABET_2_EXT
#include  image_image_ALPHABET_3_EXT
#include  image_image_ALPHABET_4_EXT
#include  image_image_ALPHABET_5_EXT
#include  image_image_ALPHABETS_EXT

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   D E S   C O N T E X T E S   G R A P H I Q U E S   D E F I N I S S A N T                            */
/*        L ' O R I G I N E   D E   C H A Q U E   S E G M E N T / C O T E   D E S   " S P E C T R E S "  ;                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   SOMMET_DE_REFERENCE                                                                                                           \
                    00

Denumer20(INIS(_00,INDEX0)
              ,_01
              ,_02
              ,_03
              ,_04
              ,_05
              ,_06
              ,_07
              ,_08
              ,_09
              ,_10
              ,_11
              ,_12
              ,_13
              ,_s1_14
              ,_s1_15
              ,_s1_16
              ,_s1_17
              ,_s2_18
              ,_s2_19
         ,nom_des_CONTEXTES_0
          );
                                        /* Nota : un nombre entier decimal ne peut commencer par un "0" sous peine d'etre traite     */
                                        /* comme un nombre octal avec donc un probleme pour "08" et "09". Dans ce cas, les           */
                                        /* contextes {01,02,...,12,13} sont donc definis sur un chiffre pour {01,02,...,08,09}       */
                                        /* et sur deux chiffres pour {10,11,12,13} et ce via 'Denumer14(....)'...                    */

Denumer20(INIS(_20,20)
              ,_21
              ,_22
              ,_23
              ,_24
              ,_25
              ,_26
              ,_27
              ,_28
              ,_29
              ,_30
              ,_31
              ,_32
              ,_33
              ,_s1_34
              ,_s1_35
              ,_s1_36
              ,_s1_37
              ,_s2_38
              ,_s2_39
         ,nom_des_CONTEXTES_2
          );
                                        /* Pour les contextes {20,21,...,32,33} il n'y a pas de differences entre l'acces direct     */
                                        /* et l'acces indexe en ce qui concerne les numeros qui sont sur deux chiffres et qui de     */
                                        /* de plus ne peuvent pas commencer par un "0"...                                            */

#define   ACCES_CONTEXTE_D(numero)                                                                                                      \
                    vecteurs_____Gcon`numero

#define   ACCES_CONTEXTE_I(numero)                                                                                                      \
                    ITb0(INDIRECT(liste_des_____vecteurs_____Gcon),numero)                                                              \
                                        /* Cas de l'acces indexe aux differents contextes graphiques...                              */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   D E S   A N G L E S  :                                                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   FAIRE_UNE_SYMETRIE_D_AXE_OY                                                                                                   \
                    VRAI
#define   NE_PAS_FAIRE_UNE_SYMETRIE_D_AXE_OY                                                                                            \
                    NOTL(FAIRE_UNE_SYMETRIE_D_AXE_OY)

DEFV(Local,DEFV(Logical,INIT(faire_une_symetrie_d_axe_OY,NE_PAS_FAIRE_UNE_SYMETRIE_D_AXE_OY)));

#define   ROTATION_PLANE(angle)                                                                                                         \
                    COND(IL_FAUT(faire_une_symetrie_d_axe_OY),NEGA(angle),NEUT(angle))

DEFV(Local,DEFV(Float,INIT(pi_sur_2,PI_SUR_2)));
DEFV(Local,DEFV(Float,INIT(pi_sur_3,PI_SUR_3)));
DEFV(Local,DEFV(Float,INIT(pi_sur_6,PI_SUR_6)));

#define   _Rzero                                                                                                                        \
                    T_ROTATION_Z(ROTATION_PLANE(FZERO))

#define   PRpis2                                                                                                                        \
                    T_ROTATION_Z(ROTATION_PLANE(NEUT(pi_sur_2)))
#define   MRpis2                                                                                                                        \
                    T_ROTATION_Z(ROTATION_PLANE(NEGA(pi_sur_2)))

#define   PRpis3                                                                                                                        \
                    T_ROTATION_Z(ROTATION_PLANE(NEUT(pi_sur_3)))
#define   MRpis3                                                                                                                        \
                    T_ROTATION_Z(ROTATION_PLANE(NEGA(pi_sur_3)))

#define   P0pis6                                                                                                                        \
                    NEUT(GRO0(UN))
#define   M0pis6                                                                                                                        \
                    NEGA(GRO0(UN))

#define   P1pis6                                                                                                                        \
                    NEUT(GRO1(UN))
#define   M1pis6                                                                                                                        \
                    NEGA(GRO1(UN))

#define   P2pis6                                                                                                                        \
                    NEUT(GRO2(UN))
#define   M2pis6                                                                                                                        \
                    NEGA(GRO2(UN))

#define   P3pis6                                                                                                                        \
                    NEUT(GRO3(UN))
#define   M3pis6                                                                                                                        \
                    NEGA(GRO3(UN))

#define   P4pis6                                                                                                                        \
                    NEUT(GRO4(UN))
#define   M4pis6                                                                                                                        \
                    NEGA(GRO4(UN))

#define   P5pis6                                                                                                                        \
                    NEUT(GRO5(UN))
#define   M5pis6                                                                                                                        \
                    NEGA(GRO5(UN))

#define   P6pis6                                                                                                                        \
                    NEUT(GRO6(UN))
#define   M6pis6                                                                                                                        \
                    NEGA(GRO6(UN))

#define   MINIMUM_pis6                                                                                                                  \
                    INTE(M6pis6)
#define   MAXIMUM_pis6                                                                                                                  \
                    INTE(P6pis6)

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P O U R   F A C I L I T E R   L A   D E T E R M I N A T I O N   D E S   A N G L E S   E T   D E S   C O N T E X T E S  :   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NUMEROTER_LES_COTES                                                                                                           \
                    VRAI
#define   NE_PAS_NUMEROTER_LES_COTES                                                                                                    \
                    NOTL(NUMEROTER_LES_COTES)
DEFV(Local,DEFV(Logical,INIT(numeroter_les_cotes,NE_PAS_NUMEROTER_LES_COTES)));

DEFV(Local,DEFV(Int,INIT(nombre_de_chiffres_des_numeros_des_cotes,DEUX)));
DEFV(Local,DEFV(Int,INIT(taille_des_caracteres_des_numeros_des_cotes,UN)));
                                        /* Pour numeroter les cotes des spectres utiles...                                           */

#define   ANGLE_DE_ROTATION(rotation)                                                                                                   \
                    ROTATION_PLANE(MUL2(FLOT(rotation),pi_sur_6))

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   D E S   T R A C E S   G R A P H I Q U E S  :                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   Zcentre_normalise                                                                                                             \
                    _____cNORMALISE_OZ(Zcentre)

#define   COTE                                                                                                                          \
                    QUATRE                                                                                                              \
                                        /* Definition du nombre d'unites sur un cote.                                                */
#define   G3                                                                                                                            \
                    Bblock                                                                                                              \
                    DO(COTE                                                                                                             \
                      ,BLOC(g3;)                                                                                                        \
                       );                                                                                                               \
                    Eblock

#define   ECHELLES                                                                                                                      \
                    UN

#define   NUMEROTER_SEGMENT(numeroter,numero,numero_minimal,numero_maximal,niveau_numeros_cotes,inverser_les_numeros)                   \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(numeroter))                                                                                            \
                         Bblock                                                                                                         \
                         DEFV(Int,INIT(numero_1,PRED(numero)));                                                                         \
                         DEFV(Int,INIT(numero_2,MODU(numero,numero_minimal,numero_maximal)));                                           \
                         DEFV(Int,INIT(numero_effectif                                                                                  \
                                      ,COND(IL_FAUT(inverser_les_numeros)                                                               \
                                           ,COND(IFGE(numero,_20)                                                                       \
                                                ,SOUS(numero,_20)                                                                       \
                                                ,ADD2(numero,_20)                                                                       \
                                                 )                                                                                      \
                                           ,numero                                                                                      \
                                            )                                                                                           \
                                       )                                                                                                \
                              );                                                                                                        \
                                                                                                                                        \
                         CALS(FgMIC());                                                                                                 \
                                                                                                                                        \
                         SET_CURSOR(NEUT(MOYE(ASD2(ACCES_CONTEXTE_I(numero_1),vecteurs_____cursor_3D,x)                                 \
                                             ,ASD2(ACCES_CONTEXTE_I(numero_2),vecteurs_____cursor_3D,x)                                 \
                                              )                                                                                         \
                                         )                                                                                              \
                                   ,NEUT(MOYE(ASD2(ACCES_CONTEXTE_I(numero_1),vecteurs_____cursor_3D,y)                                 \
                                             ,ASD2(ACCES_CONTEXTE_I(numero_2),vecteurs_____cursor_3D,y)                                 \
                                              )                                                                                         \
                                         )                                                                                              \
                                   ,ADD2(MOYE(ASD2(ACCES_CONTEXTE_I(numero_1),vecteurs_____cursor_3D,z)                                 \
                                             ,ASD2(ACCES_CONTEXTE_I(numero_2),vecteurs_____cursor_3D,z)                                 \
                                              )                                                                                         \
                                        ,tgEPSILON                                                                                      \
                                         )                                                                                              \
                                    );                                                                                                  \
                                        /* Le decalage de la coordonnee 'Z' est destine a garantir que les numeros apparaitront      */ \
                                        /* bien au premier plan. On notera au passage que les "Spectres" sont traces deux fois       */ \
                                        /* (voir 'fGENERE_SPECTRE_2(...)' appele deux fois dans 'NOUVEAU_SPECTRE_2(...)').           */ \
                                        /*                                                                                           */ \
                                        /* On notera de plus que ce decalage rapprochant les chiffres de l'observateur a pour effet  */ \
                                        /* un tres leger zoom sur ces derniers...                                                    */ \
                                                                                                                                        \
                         EGAL(Imessage_____facteur_scale_globale,GRO2(FRA4(FU)));                                                       \
                         CALS(Imessage(chain_numero(PRED(numero_effectif),nombre_de_chiffres_des_numeros_des_cotes)                     \
                                      ,Inoir_____NOIR                                                                                   \
                                      ,niveau_numeros_cotes                                                                             \
                                      ,taille_des_caracteres_des_numeros_des_cotes                                                      \
                                      ,FAUX                                                                                             \
                                       )                                                                                                \
                              );                                                                                                        \
                                                                                                                                        \
                         CALS(FgMOC());                                                                                                 \
                                                                                                                                        \
                         gA;                                                                                                            \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

#define   MEMORISER_LE_CONTEXTE                                                                                                         \
                    VRAI
#define   NE_PAS_MEMORISER_LE_CONTEXTE                                                                                                  \
                    NOTL(MEMORISER_LE_CONTEXTE)

#define   MARQUER_LE_CENTRE_DE_GRAVITE                                                                                                  \
                    VRAI
#define   NE_PAS_MARQUER_LE_CENTRE_DE_GRAVITE                                                                                           \
                    NOTL(MARQUER_LE_CENTRE_DE_GRAVITE)
DEFV(Local,DEFV(Logical,INIT(marquer_le_centre_de_gravite,NE_PAS_MARQUER_LE_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Int,INIT(nombre_de_segments,ZERO)));
DEFV(Local,DEFV(pointF_3D,centre_de_gravite));

#define   GENERE_SEGMENT(memoriser,numero,numero_minimal,numero_maximal,rotation,numeroter,niveau_numeros_cotes,inverser_les_numeros)   \
                                        /* L'argument 'memoriser' permet de tracer le "Spectre" avec ou sans memorisation (via       */ \
                                        /* 'WCG(...)') de la definition...                                                           */ \
                    Bblock                                                                                                              \
                    rotation;                                                                                                           \
                                                                                                                                        \
                    Test(IL_FAUT(memoriser))                                                                                            \
                         Bblock                                                                                                         \
                         WCG(ACCES_CONTEXTE_I(numero));                                                                                 \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    G3;gB;                                                                                                              \
                                                                                                                                        \
                    Test(IL_FAUT(marquer_le_centre_de_gravite))                                                                         \
                         Bblock                                                                                                         \
                         INCR(ASD1(centre_de_gravite,x),ASD2(ACCES_CONTEXTE_I(numero),vecteurs_____cursor_3D,x));                       \
                         INCR(ASD1(centre_de_gravite,y),ASD2(ACCES_CONTEXTE_I(numero),vecteurs_____cursor_3D,y));                       \
                         INCR(ASD1(centre_de_gravite,z),ASD2(ACCES_CONTEXTE_I(numero),vecteurs_____cursor_3D,z));                       \
                         INCR(nombre_de_segments,I);                                                                                    \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    NUMEROTER_SEGMENT(numeroter,numero,numero_minimal,numero_maximal,niveau_numeros_cotes,inverser_les_numeros);        \
                    Eblock

#define   MARQUER_LES_SQUELETTES_NIVEAU_0                                                                                               \
                    VRAI
#define   NE_PAS_MARQUER_LES_SQUELETTES_NIVEAU_0_NIVEAU_0                                                                               \
                    NOTL(MARQUER_LES_SQUELETTES_NIVEAU_0)
DEFV(Local,DEFV(Logical,INIT(marquer_les_squelettes_niveau_0,NE_PAS_MARQUER_LES_SQUELETTES_NIVEAU_0_NIVEAU_0)));
#define   MARQUER_LE_PREMIER_SQUELETTE_NIVEAU_0                                                                                         \
                    VRAI
#define   NE_PAS_MARQUER_LE_PREMIER_SQUELETTE_NIVEAU_0                                                                                  \
                    NOTL(MARQUER_LE_PREMIER_SQUELETTE_NIVEAU_0)
DEFV(Local,DEFV(Logical,INIT(marquer_le_premier_squelette_niveau_0,NE_PAS_MARQUER_LE_PREMIER_SQUELETTE_NIVEAU_0)));
#define   NIVEAU_DE_TRACE_DES_SQUELETTES_NIVEAU_0                                                                                       \
                    GRIS_2
DEFV(Local,DEFV(genere_p,INIT(niveau_de_trace_des_squelettes_niveau_0,NIVEAU_DE_TRACE_DES_SQUELETTES_NIVEAU_0)));

#define   MARQUER_LE_SQUELETTE_NIVEAU_1                                                                                                 \
                    VRAI
#define   NOMBRE_MINIMAL_DE_SPECTRES_POUR_DEFINIR_LE_SUPER_SQUELETTE                                                                    \
                    HUIT
#define   NE_PAS_MARQUER_LE_SQUELETTE_NIVEAU_1                                                                                          \
                    NOTL(MARQUER_LE_SQUELETTE_NIVEAU_1)
DEFV(Local,DEFV(Logical,INIT(marquer_le_squelette_niveau_1,NE_PAS_MARQUER_LE_SQUELETTE_NIVEAU_1)));
#define   NIVEAU_DE_TRACE_DU_SQUELETTE_NIVEAU_1                                                                                         \
                    GRIS_4
DEFV(Local,DEFV(genere_p,INIT(niveau_de_trace_du_squelette_niveau_1,NIVEAU_DE_TRACE_DU_SQUELETTE_NIVEAU_1)));

#define   DEFINITION_SQUELETTE_NIVEAU_1(contexteD,contexteA)                                                                            \
                    Bblock                                                                                                              \
                    CALS(FgMIC());                                                                                                      \
                    RCG(ACCES_CONTEXTE_I(contexteD));                                                                                   \
                    WCG(ACCES_CONTEXTE_I(contexteA));                                                                                   \
                    CALS(FgMOC());                                                                                                      \
                    Eblock

#define   GENERE_SPECTRE_n(memoriser                                                                                                    \
                          ,co_00,co_01,co_02,co_03,co_04,co_05,co_06,co_07,co_08,co_09,co_10,co_11,co_12,co_13                          \
                          ,co_s1_14,co_s1_15,co_s1_16,co_s1_17                                                                          \
                          ,numeroter                                                                                                    \
                          ,niv,inverser_les_numeros                                                                                     \
                           )                                                                                                            \
                    Bblock                                                                                                              \
                    gA;                                                                                                                 \
                                        /* Debut de la definition du "Spectre" general.                                              */ \
                                                                                                                                        \
                    Test(I3ET(EST_AUTORISE(vecteurs_____etat_trace)                                                                     \
                             ,EST_FAUX(niveau_de_trace_incremental)                                                                     \
                             ,EST_VRAI(niveau_de_trace_visualisant_la_rotation)                                                         \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         DEFV(Int,INIT(niveau_visualisant_la_rotation                                                                   \
                                      ,MODU(COND(EST_FAUX(niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation)                 \
                                                ,AXPB(facteur_____du_niveau_de_trace_visualisant_la_rotation                            \
                                                     ,NEUT(rotation_definissant_eventuellement_le_niveau)                               \
                                                     ,translation_du_niveau_de_trace_visualisant_la_rotation                            \
                                                      )                                                                                 \
                                                ,AXPB(facteur_____du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation       \
                                                     ,ABSO(rotation_definissant_eventuellement_le_niveau)                               \
                                                     ,translation_du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation       \
                                                      )                                                                                 \
                                                 )                                                                                      \
                                           ,NOIR_PLANCHER                                                                               \
                                           ,BLANC                                                                                       \
                                            )                                                                                           \
                                       )                                                                                                \
                              );                                                                                                        \
                         EGAL(niveau_de_trace,GENP(niveau_visualisant_la_rotation));                                                    \
                                                                                                                                        \
                         SET_COULEURS(NOIR,niveau_de_trace);                                                                            \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(IL_FAUT(marquer_le_centre_de_gravite))                                                                         \
                         Bblock                                                                                                         \
                         CLIR(nombre_de_segments);                                                                                      \
                         INITIALISATION_POINT_3D(centre_de_gravite,FZERO,FZERO,FZERO);                                                  \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    GENERE_SEGMENT(memoriser                                                                                            \
                                  ,co_00,co_00,co_13                                                                                    \
                                  ,_Rzero                                                                                               \
                                  ,NE_PAS_NUMEROTER_LES_COTES,niveau_numeros_cotes,inverser_les_numeros                                 \
                                   );                                                                                                   \
                                        /* Le premier numero ('co_00') ne peut apparaitre que lors de la definition du second        */ \
                                        /* segment...                                                                                */ \
                    WCG(ACCES_CONTEXTE_I(co_s1_14));                                                                                    \
                    GENERE_SEGMENT(memoriser,co_01,co_00,co_13,PRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_02,co_00,co_13,MRpis2,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    WCG(ACCES_CONTEXTE_I(co_s1_15));                                                                                    \
                    GENERE_SEGMENT(memoriser,co_03,co_00,co_13,PRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_04,co_00,co_13,PRpis2,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_05,co_00,co_13,MRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_06,co_00,co_13,PRpis2,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_07,co_00,co_13,MRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_08,co_00,co_13,PRpis2,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    WCG(ACCES_CONTEXTE_I(co_s1_16));                                                                                    \
                    GENERE_SEGMENT(memoriser,co_09,co_00,co_13,PRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_10,co_00,co_13,_Rzero,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_11,co_00,co_13,PRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    GENERE_SEGMENT(memoriser,co_12,co_00,co_13,MRpis2,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                    WCG(ACCES_CONTEXTE_I(co_s1_17));                                                                                    \
                    GENERE_SEGMENT(memoriser,co_13,co_00,co_13,PRpis3,numeroter,niveau_numeros_cotes,inverser_les_numeros);             \
                                        /* Fin de la definition du "Spectre" general.                                                */ \
                                        /*                                                                                           */ \
                                        /* On notera l'inversion des signes des rotations par rapport a 'v $xrd/spectre.01$K'...     */ \
                                                                                                                                        \
                    NUMEROTER_SEGMENT(numeroter,SUCC(co_13),co_00,co_13,niveau_numeros_cotes,inverser_les_numeros);                     \
                                        /* L'eventuel dernier numerotage est particulier puisque le sommet 'SUCC(co_13)' n'existe    */ \
                                        /* pas (c'est en fait 'co_00'...).                                                           */ \
                                                                                                                                        \
                    Test(EST_AUTORISE(vecteurs_____etat_trace))                                                                         \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(marquer_les_squelettes_niveau_0))                                                                 \
                              Bblock                                                                                                    \
                              Test(IFOU(IL_FAUT(marquer_le_premier_squelette_niveau_0)                                                  \
                                       ,IFET(IL_NE_FAUT_PAS(marquer_le_premier_squelette_niveau_0)                                      \
                                            ,IZGT(nombre_de_spectres_traces)                                                            \
                                             )                                                                                          \
                                        )                                                                                               \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                   CALS(FgMIC());                                                                                       \
                                   CALS(FgMIN());                                                                                       \
                                                                                                                                        \
                                   RCG(ACCES_CONTEXTE_I(co_s1_14));                                                                     \
                                   gA;                                                                                                  \
                                   RCG(ACCES_CONTEXTE_I(co_s1_15));                                                                     \
                                   SET_COULEURS(NOIR,niveau_de_trace_des_squelettes_niveau_0);                                          \
                                   gB;                                                                                                  \
                                   RCG(ACCES_CONTEXTE_I(co_s1_16));                                                                     \
                                   SET_COULEURS(NOIR,niveau_de_trace_des_squelettes_niveau_0);                                          \
                                   gB;                                                                                                  \
                                   RCG(ACCES_CONTEXTE_I(co_s1_17));                                                                     \
                                   SET_COULEURS(NOIR,niveau_de_trace_des_squelettes_niveau_0);                                          \
                                   gB;                                                                                                  \
                                   RCG(ACCES_CONTEXTE_I(co_s1_14));                                                                     \
                                   SET_COULEURS(NOIR,niveau_de_trace_des_squelettes_niveau_0);                                          \
                                   gB;                                                                                                  \
                                                                                                                                        \
                                   CALS(FgMON());                                                                                       \
                                   CALS(FgMOC());                                                                                       \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         Test(IL_FAUT(marquer_le_centre_de_gravite))                                                                    \
                              Bblock                                                                                                    \
                              EGAL(ASD1(centre_de_gravite,x),DIVI(ASD1(centre_de_gravite,x),FLOT(nombre_de_segments)));                 \
                              EGAL(ASD1(centre_de_gravite,y),DIVI(ASD1(centre_de_gravite,y),FLOT(nombre_de_segments)));                 \
                              EGAL(ASD1(centre_de_gravite,z),DIVI(ASD1(centre_de_gravite,z),FLOT(nombre_de_segments)));                 \
                                                                                                                                        \
                              CALS(FgMIC());                                                                                            \
                                                                                                                                        \
                              SET_CURSOR(ASD1(centre_de_gravite,x)                                                                      \
                                        ,ASD1(centre_de_gravite,y)                                                                      \
                                        ,ASD1(centre_de_gravite,z)                                                                      \
                                         );                                                                                             \
                                                                                                                                        \
                              gA;                                                                                                       \
                              gB;                                                                                                       \
                                                                                                                                        \
                              CALS(FgMOC());                                                                                            \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(I3ET(EST_AUTORISE(vecteurs_____etat_trace)                                                                     \
                             ,EST_VRAI(niveau_de_trace_incremental)                                                                     \
                             ,EST_FAUX(niveau_de_trace_visualisant_la_rotation)                                                         \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         DEFV(Int,INIT(niveau_incremente,MODU(ADD2(INTE(niveau_de_trace),PAS_COULEURS),NOIR_PLANCHER,BLANC)));          \
                         EGAL(niveau_de_trace,GENP(niveau_incremente));                                                                 \
                                                                                                                                        \
                         SET_COULEURS(NOIR,niveau_de_trace);                                                                            \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

#define   ROTATION_INITIALE                                                                                                             \
                    Bblock                                                                                                              \
                    INITIALISATION_SYSTEMATIQUE_TRANSFORMATION;                                                                         \
                                                                                                                                        \
                    Test(IL_FAUT(faire_une_rotation_initiale))                                                                          \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(faire_une_symetrie_d_axe_OY))                                                                     \
                              Bblock                                                                                                    \
                              TRZ(GRO3(PI_SUR_4));                                                                                      \
                                        /* On se retrouve alors dans le cas de 'v $xrd/spectre.01$K'...                              */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              TRZ(GRO1(PI_SUR_4));                                                                                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

#define   GENERE_SPECTRE_0(memoriser,niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros)                                        \
                    Bblock                                                                                                              \
                    SET_COULEURS(NOIR,niveau);                                                                                          \
                    GENERE_SPECTRE_n(memoriser                                                                                          \
                                    ,_00,_01,_02,_03,_04,_05,_06,_07,_08,_09,_10,_11,_12,_13,_s1_14,_s1_15,_s1_16,_s1_17                \
                                    ,numeroter,niveau_numeros_cotes,inverser_les_numeros                                                \
                                     );                                                                                                 \
                                        /* Definition du "Spectre" 0.                                                                */ \
                                                                                                                                        \
                    INCR(nombre_de_spectres_traces,I);                                                                                  \
                                        /* On notera que 'GENERE_SPECTRE_0(...)' est toujours execute (ce qui fait qu'on trace       */ \
                                        /* toujours au moins un "Spectre", le "Spectre" 0...), contrairement aux suivants via        */ \
                                        /* 'NOUVEAU_SPECTRE_2(...)' qui permet de n'en tracer que 1,2,3,...                          */ \
                    Eblock
#define   GENERE_SPECTRE_2(memoriser,numeroter,niveau_numeros_cotes,inverser_les_numeros)                                               \
                    Bblock                                                                                                              \
                    GENERE_SPECTRE_n(memoriser                                                                                          \
                                    ,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_s1_34,_s1_35,_s1_36,_s1_37                \
                                    ,numeroter,niveau_numeros_cotes,inverser_les_numeros                                                \
                                     );                                                                                                 \
                                        /* Definition du "Spectre" 2.                                                                */ \
                    Eblock

#define   TRANSLATION_CURSOR(contexteD,contexteA)                                                                                       \
                    Bblock                                                                                                              \
                    SET_CURSOR(ADD2(ASD1(vecteurs_____cursor_3D,x)                                                                      \
                                   ,SOUS(ASD2(ACCES_CONTEXTE_I(contexteA),vecteurs_____cursor_3D,x)                                     \
                                        ,ASD2(ACCES_CONTEXTE_I(contexteD),vecteurs_____cursor_3D,x)                                     \
                                         )                                                                                              \
                                    )                                                                                                   \
                              ,ADD2(ASD1(vecteurs_____cursor_3D,y)                                                                      \
                                   ,SOUS(ASD2(ACCES_CONTEXTE_I(contexteA),vecteurs_____cursor_3D,y)                                     \
                                        ,ASD2(ACCES_CONTEXTE_I(contexteD),vecteurs_____cursor_3D,y)                                     \
                                         )                                                                                              \
                                    )                                                                                                   \
                              ,Zcentre_normalise                                                                                        \
                               );                                                                                                       \
                    Eblock

#define   NOUVEAU_SPECTRE_2_1(rotation,numeroter,niveau_numeros_cotes,inverser_les_numeros)                                             \
                    Bblock                                                                                                              \
                    RCG(ACCES_CONTEXTE_D(SOMMET_DE_REFERENCE));                                                                         \
                    ROTATION_INITIALE;                                                                                                  \
                    TRZ(ANGLE_DE_ROTATION(rotation));                                                                                   \
                                                                                                                                        \
                    SET_TRACE(INTERDIT);                                                                                                \
                    CALS(fGENERE_SPECTRE_2(MEMORISER_LE_CONTEXTE,numeroter,niveau_numeros_cotes,inverser_les_numeros));                 \
                                        /* Pourquoi ne peut-on pas supprimer ce 'GENERE_SPECTRE_2(VRAI)' identique strictement       */ \
                                        /* a celui qui suit un peu plus bas ? Le 20230731093733, je note que la difference entre     */ \
                                        /* les deux est la presence de 'TRANSLATION_CURSOR(...)' entre eux...                        */ \
                                                                                                                                        \
                    RCG(ACCES_CONTEXTE_D(SOMMET_DE_REFERENCE));                                                                         \
                    ROTATION_INITIALE;                                                                                                  \
                    TRZ(ANGLE_DE_ROTATION(rotation));                                                                                   \
                    Eblock
#define   NOUVEAU_SPECTRE_2_2(niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros)                                               \
                    Bblock                                                                                                              \
                    SET_TRACE(AUTORISE);                                                                                                \
                    SET_COULEURS(NOIR,niveau);                                                                                          \
                    CALS(fGENERE_SPECTRE_2(MEMORISER_LE_CONTEXTE,numeroter,niveau_numeros_cotes,inverser_les_numeros));                 \
                    Eblock

DEFV(Local,DEFV(Int,INIT(rotation_definissant_eventuellement_le_niveau,P0pis6)));
                                        /* Initialisation a priori sur le premier spectre 'GENERE_SPECTRE_0(...)'.                   */

#define   DEPLACER__0_2                                                                                                                 \
                    VRAI
#define   NE_PAS_DEPLACER__0_2                                                                                                          \
                    NOTL(DEPLACER__0_2)
#define   NOUVEAU_SPECTRE_2(deplacer__0_2,niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros,rotation,contexteA,contexteD)      \
                    Bblock                                                                                                              \
                    Test(IFLT(nombre_de_spectres_traces,nombre_maximal_de_spectres))                                                    \
                                        /* Contrairement a 'GENERE_SPECTRE_0(...)' qui est inconditionnel, 'NOUVEAU_SPECTRE_2(...)'  */ \
                                        /* est conditionnel ce qui permet de ne tracer que 1,2,3,... "Spectre"s...                   */ \
                         Bblock                                                                                                         \
                         EGAL(rotation_definissant_eventuellement_le_niveau,rotation);                                                  \
                                        /* Au cas ou...                                                                              */ \
                                                                                                                                        \
                         Test(IL_FAUT(deplacer__0_2))                                                                                   \
                              Bblock                                                                                                    \
                              CALS(fMOVE_SPECTRE_0_2());                                                                                \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         CALS(fNOUVEAU_SPECTRE_2_1(rotation,NE_PAS_NUMEROTER_LES_COTES,niveau_numeros_cotes,inverser_les_numeros));     \
                                                                                                                                        \
                         TRANSLATION_CURSOR(contexteD,contexteA);                                                                       \
                                                                                                                                        \
                         CALS(fNOUVEAU_SPECTRE_2_2(niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros));                        \
                                                                                                                                        \
                         INCR(nombre_de_spectres_traces,I);                                                                             \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

#define   MOVE_SPECTRE_0_2                                                                                                              \
                    Bblock                                                                                                              \
                    MCG(vecteurs_____Gcon_00,vecteurs_____Gcon_20);                                                                     \
                    MCG(vecteurs_____Gcon_01,vecteurs_____Gcon_21);                                                                     \
                    MCG(vecteurs_____Gcon_02,vecteurs_____Gcon_22);                                                                     \
                    MCG(vecteurs_____Gcon_03,vecteurs_____Gcon_23);                                                                     \
                    MCG(vecteurs_____Gcon_04,vecteurs_____Gcon_24);                                                                     \
                    MCG(vecteurs_____Gcon_05,vecteurs_____Gcon_25);                                                                     \
                    MCG(vecteurs_____Gcon_06,vecteurs_____Gcon_26);                                                                     \
                    MCG(vecteurs_____Gcon_07,vecteurs_____Gcon_27);                                                                     \
                    MCG(vecteurs_____Gcon_08,vecteurs_____Gcon_28);                                                                     \
                    MCG(vecteurs_____Gcon_09,vecteurs_____Gcon_29);                                                                     \
                    MCG(vecteurs_____Gcon_10,vecteurs_____Gcon_30);                                                                     \
                    MCG(vecteurs_____Gcon_11,vecteurs_____Gcon_31);                                                                     \
                    MCG(vecteurs_____Gcon_12,vecteurs_____Gcon_32);                                                                     \
                    MCG(vecteurs_____Gcon_13,vecteurs_____Gcon_33);                                                                     \
                    Eblock

#define   AIDES_DIVERSES_APRES_LE_TRACE                                                                                                 \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(editer_les_mises_a_jour_a_effectuer))                                                                  \
                         Bblock                                                                                                         \
                         CAL3(Prme0("Pas de mise a jour\n"));                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(IL_FAUT(editer_le_nombre_de_spectres_traces))                                                                  \
                         Bblock                                                                                                         \
                         CAL3(Prme1("NombreSpectres=%d\n",nombre_de_spectres_traces));                                                  \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(IL_FAUT(trace_un_cadre_carre))                                                                                 \
                         Bblock                                                                                                         \
                         DEFV(Float,INIT(moyenne_des_extrema_Z                                                                          \
                                        ,MOYE(DRAW_____minimum_Z__trace_AUTORISE,DRAW_____maximum_Z__trace_AUTORISE)                    \
                                         )                                                                                              \
                              );                                                                                                        \
                                                                                                                                        \
                         Test(IFNE_a_peu_pres_absolu(moyenne_des_extrema_Z,Zcentre_normalise,tgEPSILON))                                \
                              Bblock                                                                                                    \
                              PRINT_ATTENTION("il y a un probleme avec la coordonnee 'Z'");                                             \
                              CAL1(Prer2("(la moyenne des extrema vaut %+.^^^ alors qu'elle devrait valoir %+.^^^)\n"                   \
                                        ,moyenne_des_extrema_Z                                                                          \
                                        ,Zcentre_normalise                                                                              \
                                         )                                                                                              \
                                   );                                                                                                   \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         SET_COULEURS(NOIR,niveau_du_cadre);                                                                            \
                                                                                                                                        \
                         SET_CURSOR(DRAW_____minimum_X__trace_AUTORISE                                                                  \
                                   ,DRAW_____minimum_Y__trace_AUTORISE                                                                  \
                                   ,moyenne_des_extrema_Z                                                                               \
                                    );                                                                                                  \
                         gA;                                                                                                            \
                                                                                                                                        \
                         SET_CURSOR(DRAW_____maximum_X__trace_AUTORISE                                                                  \
                                   ,DRAW_____minimum_Y__trace_AUTORISE                                                                  \
                                   ,moyenne_des_extrema_Z                                                                               \
                                    );                                                                                                  \
                         gB;                                                                                                            \
                                                                                                                                        \
                         SET_CURSOR(DRAW_____maximum_X__trace_AUTORISE                                                                  \
                                   ,DRAW_____maximum_Y__trace_AUTORISE                                                                  \
                                   ,moyenne_des_extrema_Z                                                                               \
                                    );                                                                                                  \
                         gB;                                                                                                            \
                                                                                                                                        \
                         SET_CURSOR(DRAW_____minimum_X__trace_AUTORISE                                                                  \
                                   ,DRAW_____maximum_Y__trace_AUTORISE                                                                  \
                                   ,moyenne_des_extrema_Z                                                                               \
                                    );                                                                                                  \
                         gB;                                                                                                            \
                                                                                                                                        \
                         SET_CURSOR(DRAW_____minimum_X__trace_AUTORISE                                                                  \
                                   ,DRAW_____minimum_Y__trace_AUTORISE                                                                  \
                                   ,moyenne_des_extrema_Z                                                                               \
                                    );                                                                                                  \
                         gB;                                                                                                            \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   X_CENTRE_DU_PAVAGE                                                                                                            \
                    DIVI(FLOT(230),FLOT(dimX_BASE))
#define   Y_CENTRE_DU_PAVAGE                                                                                                            \
                    DIVI(FLOT(256),FLOT(dimY_BASE))
                                        /* Centre du pavage...                                                                       */

#define   NOMBRE_MAXIMAL_DE_SPECTRES                                                                                                    \
                    INFINI
#define   EDITER_LE_NOMBRE_DE_SPECTRES_TRACES                                                                                           \
                    FAUX
                                        /* Pour gerer le nombre de spectres...                                                       */

#define   EDITER_LES_MISES_A_JOUR_A_EFFECTUER                                                                                           \
                    FAUX                                                                                                                \
                                        /* Faut-il editer les mises a jour a effectuer dans ce '$K' ?                                */

#define   FAIRE_UNE_ROTATION_INITIALE                                                                                                   \
                    VRAI                                                                                                                \
                                        /* Faut-il faire une rotation initiale de (3.pi)/4 ?                                         */

#define   ECHELLE_GLOBALE                                                                                                               \
                    GRO3(FRA2(FU))                                                                                                      \
                                        /* Echelle globale...                                                                        */

#define   NIVEAU_DE_TRACE_DE_TOUS_LES_SPECTRES                                                                                          \
                    GRIS_1
                                        /* Niveau general de trace...                                                                */

#define   NIVEAU_DE_TRACE_INCREMENTAL                                                                                                   \
                    VRAI
#define   NIVEAU_DE_TRACE_FIXE                                                                                                          \
                    NOTL(NIVEAU_DE_TRACE_INCREMENTAL)
                                        /* Gestion du niveau general de trace incremental...                                         */

#define   NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION                                                                                       \
                    VRAI
#define   NIVEAU_DE_TRACE_NE_VISUALISANT_PAS_LA_ROTATION                                                                                \
                    NOTL(NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION)

#define   FACTEUR_____DU_NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION                                                                        \
                    SEIZE
#define   TRANSLATION_DU_NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION                                                                        \
                    ADD2(GRIS_0,MOIT(COULEURS))
                                        /* On notera qu'il y 13 angles possibles {-6,-5,-4,-3,-2,-1,0,+1,+2,+3,+4,+5,+6}. La         */
                                        /* symetrie par rapport a 0 implique que la translation des niveaux soient situees au        */
                                        /* milieu de {NOIR,BLANC}. Enfin, le facteur doit etre inferieur ou egal a la translation    */
                                        /* divisee par 7 (=6+1, soit le cardinal de {0,+1,+2,+3,+4,+5,+6}) qui est egal a 18.28 ;    */
                                        /* on prend donc 16...                                                                       */

#define   NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION                                                                  \
                    VRAI
#define   NIVEAU_DE_TRACE_NE_VISUALISANT_PAS_LA_VALEUR_ABSOLUE_DE_LA_ROTATION                                                           \
                    NOTL(NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION)

#define   FACTEUR_____DU_NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION                                                   \
                    ADD2(GRO2(FACTEUR_____DU_NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION),CINQ)
#define   TRANSLATION_DU_NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION                                                   \
                    ADD2(GRIS_1,DEUX)
                                        /* Gestion du niveau general de trace visualisant la rotation. En fait il y a en "gros"      */
                                        /* un facteur 2 (a cause de la valeur absolue qui nous ramene a {0,+1,+2,+3,+4,+5,+6})       */
                                        /* avec la parametrage du cas sans valeur absolue. Les parametres par defaut placent         */
                                        /* les niveaux de remplissage dans [$GRIS_1,$GRIS_8]...                                      */

#define   NIVEAU_DU_CADRE                                                                                                               \
                    GRIS_4                                                                                                              \
                                        /* Niveau du cadre...                                                                        */

#define   ANTI_ALIASING                                                                                                                 \
                    FAUX                                                                                                                \
                                        /* Etat de l'anti-aliasing...                                                                */

#define   TRACE_UN_CADRE_CARRE                                                                                                          \
                    FAUX                                                                                                                \
                                        /* Afin de pouvoir tracer un cadre carre englobant l'ensemble des spectres...                */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N S   D E S T I N E E S   A   O P T I M I S E R   L E   C O D E  :                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
DEFV(Local,DEFV(Int,INIT(nombre_de_spectres_traces,ZERO)));

DEFV(Local,DEFV(genere_p,INIT(niveau_de_trace,NIVEAU_DE_TRACE_DE_TOUS_LES_SPECTRES)));
                                        /* Niveaux generaux de trace...                                                              */
DEFV(Local,DEFV(Logical,INIT(niveau_de_trace_incremental,NIVEAU_DE_TRACE_FIXE)));

DEFV(Local,DEFV(Logical,INIT(niveau_de_trace_visualisant_la_rotation,NIVEAU_DE_TRACE_NE_VISUALISANT_PAS_LA_ROTATION)));
DEFV(Local,DEFV(Int,INIT(facteur_____du_niveau_de_trace_visualisant_la_rotation
                        ,FACTEUR_____DU_NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION
                         )
                )
     );
DEFV(Local,DEFV(Int,INIT(translation_du_niveau_de_trace_visualisant_la_rotation
                        ,TRANSLATION_DU_NIVEAU_DE_TRACE_VISUALISANT_LA_ROTATION
                         )
                )
     );
DEFV(Local,DEFV(Logical,INIT(niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                            ,NIVEAU_DE_TRACE_NE_VISUALISANT_PAS_LA_VALEUR_ABSOLUE_DE_LA_ROTATION
                             )
                )
     );
DEFV(Local,DEFV(Int,INIT(facteur_____du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                        ,FACTEUR_____DU_NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION
                         )
                )
     );
DEFV(Local,DEFV(Int,INIT(translation_du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                        ,TRANSLATION_DU_NIVEAU_DE_TRACE_VISUALISANT_LA_VALEUR_ABSOLUE_DE_LA_ROTATION
                         )
                )
     );

BFonctionV

DEFV(Local,DEFV(FonctionV,fGENERE_SPECTRE_0(memoriser,niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros)))
DEFV(Argument,DEFV(Logical,memoriser));
DEFV(Argument,DEFV(genere_p,niveau));
DEFV(Argument,DEFV(Logical,numeroter));
DEFV(Argument,DEFV(genere_p,niveau_numeros_cotes));
DEFV(Argument,DEFV(Logical,inverser_les_numeros));
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     /*..............................................................................................................................*/
     GENERE_SPECTRE_0(memoriser,niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros);

     RETU_VIDE
     Eblock

EFonctionV

BFonctionV

DEFV(Local,DEFV(FonctionV,fGENERE_SPECTRE_2(memoriser,numeroter,niveau_numeros_cotes,inverser_les_numeros)))
DEFV(Argument,DEFV(Logical,memoriser));
DEFV(Argument,DEFV(Logical,numeroter));
DEFV(Argument,DEFV(genere_p,niveau_numeros_cotes));
DEFV(Argument,DEFV(Logical,inverser_les_numeros));
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     /*..............................................................................................................................*/
     GENERE_SPECTRE_2(memoriser,numeroter,niveau_numeros_cotes,inverser_les_numeros);

     RETU_VIDE
     Eblock

EFonctionV

BFonctionV

DEFV(Local,DEFV(Logical,INIT(faire_une_rotation_initiale,FAIRE_UNE_ROTATION_INITIALE)));
                                        /* Faut-il faire une rotation initiale de (3.pi)/4 ?                                         */

DEFV(Local,DEFV(FonctionV,fNOUVEAU_SPECTRE_2_1(rotation,numeroter,niveau_numeros_cotes,inverser_les_numeros)))
DEFV(Argument,DEFV(Int,rotation));
DEFV(Argument,DEFV(Logical,numeroter));
DEFV(Argument,DEFV(genere_p,niveau_numeros_cotes));
DEFV(Argument,DEFV(Logical,inverser_les_numeros));
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     /*..............................................................................................................................*/
     NOUVEAU_SPECTRE_2_1(rotation,numeroter,niveau_numeros_cotes,inverser_les_numeros);

     RETU_VIDE
     Eblock

EFonctionV

BFonctionV

DEFV(Local,DEFV(FonctionV,fNOUVEAU_SPECTRE_2_2(niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros)))
DEFV(Argument,DEFV(genere_p,niveau));
DEFV(Argument,DEFV(Logical,numeroter));
DEFV(Argument,DEFV(genere_p,niveau_numeros_cotes));
DEFV(Argument,DEFV(Logical,inverser_les_numeros));
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     /*..............................................................................................................................*/
     NOUVEAU_SPECTRE_2_2(niveau,numeroter,niveau_numeros_cotes,inverser_les_numeros);

     RETU_VIDE
     Eblock

EFonctionV

BFonctionV

DEFV(Local,DEFV(FonctionV,fMOVE_SPECTRE_0_2()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     /*..............................................................................................................................*/
     MOVE_SPECTRE_0_2;

     RETU_VIDE
     Eblock

EFonctionV

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T R A C E   D U   S P E C T R E  :                                                                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));

     DEFV(Float,INIT(X_centre_du_pavage,X_CENTRE_DU_PAVAGE));
     DEFV(Float,INIT(Y_centre_du_pavage,Y_CENTRE_DU_PAVAGE));
                                        /* Centre du pavage...                                                                       */

     DEFV(Int,INIT(nombre_maximal_de_spectres,NOMBRE_MAXIMAL_DE_SPECTRES));
     DEFV(Logical,INIT(editer_le_nombre_de_spectres_traces,EDITER_LE_NOMBRE_DE_SPECTRES_TRACES));
                                        /* Pour gerer le nombre de spectres...                                                       */

     DEFV(Logical,INIT(editer_les_mises_a_jour_a_effectuer,EDITER_LES_MISES_A_JOUR_A_EFFECTUER));
                                        /* Pour editer les mises a jour a effectuer dans ce '$K' pour la prochaine iteration...      */

     DEFV(Float,INIT(echelle_globale,ECHELLE_GLOBALE));
                                        /* Echelle globale...                                                                        */

     DEFV(Logical,INIT(anti_aliasing,ANTI_ALIASING));
                                        /* Etat de l'anti-aliasing...                                                                */

     DEFV(Logical,INIT(trace_un_cadre_carre,TRACE_UN_CADRE_CARRE));
                                        /* Afin de pouvoir tracer un cadre carre englobant l'ensemble des spectres...                */
     DEFV(genere_p,INIT(niveau_du_cadre,NIVEAU_DU_CADRE));
                                        /* Niveau general de trace...                                                                */
     /*..............................................................................................................................*/
     GET_ARGUMENTSv(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_L("SX_SY_SZ_____compatibilite_20070416=""compatibilite_20070416="
                                       ,SX_SY_SZ_____compatibilite_20070416
                                        );
                         GET_ARGUMENT_L("Ipoint_anti_aliase_segment_____compatibilite_20110420=""compatibilite_20110420="
                                       ,Ipoint_anti_aliase_segment_____compatibilite_20110420
                                        );

                         GET_ARGUMENT_C("imageR=""R=",nom_imageR);

                         GET_ARGUMENT_L("rotation_initiale=""ri=",faire_une_rotation_initiale);
                         GET_ARGUMENT_L("symetrie_OY=""sOY=",faire_une_symetrie_d_axe_OY);

                         GET_ARGUMENT_F("pis2=""p2=",pi_sur_2);
                         GET_ARGUMENT_F("pis3=""p3=",pi_sur_3);
                         GET_ARGUMENT_F("pis6=""p6=",pi_sur_6);

                         GET_ARGUMENT_F("X_centre=""Xc=",X_centre_du_pavage);
                         GET_ARGUMENT_F("Y_centre=""Yc=",Y_centre_du_pavage);

                         GET_ARGUMENT_I("nombre_maximal_spectres=""nms=",nombre_maximal_de_spectres);
                                        /* Pour obtenir les deux "clusters" interessant de "Spectres"s (incluant un "Mystic" au      */
                                        /* passage), il faut choisir respectivement :                                                */
                                        /*                                                                                           */
                                        /*                  nombre_maximal_spectres=8                                                */
                                        /*                  nombre_maximal_spectres=9                                                */
                                        /*                                                                                           */
                         GET_ARGUMENT_L("editer_nombre_spectres=""ens=",editer_le_nombre_de_spectres_traces);

                         GET_ARGUMENT_L("mises_a_jour=""maj=",editer_les_mises_a_jour_a_effectuer);

                         GET_ARGUMENT_L("numeroter_cotes=""nc=",numeroter_les_cotes);

                         GET_ARGUMENT_L("squelettes=""ms=""squelette_0=""ms0=",marquer_les_squelettes_niveau_0);
                         GET_ARGUMENT_L("premier_squelette=""mps=""premier_squelette_0=""mps0=",marquer_le_premier_squelette_niveau_0);
                         GET_ARGUMENT_P("niveau_squelette=""ns=""niveau_squelette_0=""ns0=",niveau_de_trace_des_squelettes_niveau_0);
                                        /* Le marquage optionnel du premier squelette est lie a l'existence des deux "clusters"      */
                                        /* interessant de "Spectres"s (incluant un "Mystic" au passage) pour lesquels le premier     */
                                        /* squelette ne doit pas etre marque...                                                      */

                         GET_ARGUMENT_L("super_squelette=""mss=""squelette_1=""ms1="
                                       ,marquer_le_squelette_niveau_1
                                        );
                         GET_ARGUMENT_P("niveau_super_squelette=""nss=""niveau_squelette_1=""ns1="
                                       ,niveau_de_trace_du_squelette_niveau_1
                                        );

                         GET_ARGUMENT_L("centre_gravite=""G=",marquer_le_centre_de_gravite);

                         GET_ARGUMENT_F("echelle=",echelle_globale);

                         GET_ARGUMENT_P("niveau=""n=",niveau_de_trace);

                         GET_ARGUMENT_L("niveau_incremental=""ni=",niveau_de_trace_incremental);

                         GET_ARGUMENT_L("niveau_rotation=""nr=",niveau_de_trace_visualisant_la_rotation);
                         GET_ARGUMENT_I("Aniveau_rotation=""Anr=",facteur_____du_niveau_de_trace_visualisant_la_rotation);
                         GET_ARGUMENT_I("Bniveau_rotation=""Bnr=",translation_du_niveau_de_trace_visualisant_la_rotation);

                         GET_ARGUMENT_L("niveau_rotation_absolue=""nra="
                                       ,niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                                        );
                         GET_ARGUMENT_I("Aniveau_rotation_absolue=""Anra="
                                       ,facteur_____du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                                        );
                         GET_ARGUMENT_I("Bniveau_rotation_absolue=""Bnra="
                                       ,translation_du_niveau_de_trace_visualisant_la_valeur_absolue_de_la_rotation
                                        );

                         GET_ARGUMENT_L("anti_aliasing=""aa=",anti_aliasing);
                         GET_ARGUMENT_L("editer_vecteurs=""ev=",IFsegment_____editer_le_vecteur_bidimensionnel);
                         GET_ARGUMENT_L("trier_vecteurs=""tv=",IFsegment_____trier_puis_editer_le_vecteur_bidimensionnel);
                                        /* L'argument de tri a ete introduit le 20231012142606...                                    */

                         GET_ARGUMENT_L("cadre=""cc=",trace_un_cadre_carre);
                         GET_ARGUMENT_P("niveau_cadre=""nk=",niveau_du_cadre);
                         )
                    );

     Test(IFNE(SOMMET_DE_REFERENCE,_00))
          Bblock
          PRINT_ERREUR("le numerotage des contextes graphiques est incoherent, on aborte donc");
          CAL1(Prer2("(le sommet de reference est %d alors que le premier contexte est %d)\n",SOMMET_DE_REFERENCE,_00));

          Exit(PROBLEMES);
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     Test(IFLT(nombre_maximal_de_spectres,UN))
          Bblock
          PRINT_ATTENTION("au moins un 'Spectre' va etre trace");
          EGAL(nombre_maximal_de_spectres,UN);
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     Test(IFET(IL_FAUT(marquer_le_squelette_niveau_1)
              ,IFLT(nombre_maximal_de_spectres,NOMBRE_MINIMAL_DE_SPECTRES_POUR_DEFINIR_LE_SUPER_SQUELETTE)
               )
          )
          Bblock
          PRINT_ATTENTION("il n'y a pas assez de 'Spectre's pour marquer le 'super-squelette'");
          CAL1(Prer1("(il en faut au moins %d)\n",NOMBRE_MINIMAL_DE_SPECTRES_POUR_DEFINIR_LE_SUPER_SQUELETTE));
          EGAL(marquer_le_squelette_niveau_1,FAUX);
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     Test(IL_FAUT(numeroter_les_cotes))
          Bblock
          EGAL(FgL0_00_____remplacer_par_un_O,VRAI);
                                        /* Pour plus de lisibilite...                                                                */
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     SUPER_ECHELLE_PETIT_CARRE;
                                        /* Choix du format des figures obtenues :                                                    */
                                        /*                                                                                           */
                                        /*                  SUPER_ECHELLE_RECTANGULAIRE;                                             */
                                        /*                  SUPER_ECHELLE_PETIT_CARRE;                                               */
                                        /*                  SUPER_ECHELLE_GRAND_CARRE;                                               */
                                        /*                                                                                           */

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

     CALS(FgERASE());
                                        /* Clear...                                                                                  */
     SET_FILTRAGE(ACTIF);

     CALS(Iinit_Z_Buffer());
     SET_ANTI_ALIASING(anti_aliasing);

     SKH(ECHELLES);
                                        /* Definition de l'echelle globale.                                                          */
     SXH(ECHELLES);
                                        /* Definition de l'echelle sur l'axe des 'X'.                                                */
     SYH(ECHELLES);
                                        /* Definition de l'echelle sur l'axe des 'Y'.                                                */

     SKH(echelle_globale);
                                        /* Changement de l'echelle globale.                                                          */

     SET_TRACE(AUTORISE);
     EGAL(DRAW_____initialiser_les_extrema_de_X_Y_Z,VRAI);

     SET_CURSOR(X_centre_du_pavage
               ,Y_centre_du_pavage
               ,Zcentre_normalise
                );

     ROTATION_INITIALE;

     CALS(fGENERE_SPECTRE_0(MEMORISER_LE_CONTEXTE,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,GRIS_5,FAUX));
                                        /* Definition et generation du "Spectre" central (de base)...                                */

     NOUVEAU_SPECTRE_2(NE_PAS_DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,FAUX
                      ,P3pis6,_00,_28
                       );

     NOUVEAU_SPECTRE_2(NE_PAS_DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,FAUX
                      ,P5pis6,_04,_26
                       );

     DEFINITION_SQUELETTE_NIVEAU_1(_21,_s2_18);

     NOUVEAU_SPECTRE_2(NE_PAS_DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,FAUX
                      ,P1pis6,_04,_20
                       );

     NOUVEAU_SPECTRE_2(DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,VRAI
                      ,M3pis6,_09,_29
                       );

     DEFINITION_SQUELETTE_NIVEAU_1(_33,_s2_19);

     NOUVEAU_SPECTRE_2(DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,VRAI
                      ,M1pis6,_01,_29
                       );

     DEFINITION_SQUELETTE_NIVEAU_1(_21,_s2_38);

     NOUVEAU_SPECTRE_2(DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,VRAI
                      ,M1pis6,_05,_31
                       );

     NOUVEAU_SPECTRE_2(DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,VRAI
                      ,P1pis6,_03,_27
                       );

     DEFINITION_SQUELETTE_NIVEAU_1(_33,_s2_39);

     NOUVEAU_SPECTRE_2(DEPLACER__0_2,niveau_de_trace,NE_PAS_NUMEROTER_LES_COTES,NIVEAU_UNDEF,VRAI
                      ,P3pis6,_02,_28
                       );

     AIDES_DIVERSES_APRES_LE_TRACE;

     Test(EST_AUTORISE(vecteurs_____etat_trace))
          Bblock
          Test(IL_FAUT(marquer_le_squelette_niveau_1))
               Bblock
               CALS(FgMIC());
               CALS(FgMIN());

               RCG(ACCES_CONTEXTE_I(_s2_18));
               gA;
               RCG(ACCES_CONTEXTE_I(_s2_19));
               SET_COULEURS(NOIR,niveau_de_trace_du_squelette_niveau_1);
               gB;
               RCG(ACCES_CONTEXTE_I(_s2_38));
               SET_COULEURS(NOIR,niveau_de_trace_du_squelette_niveau_1);
               gB;
               RCG(ACCES_CONTEXTE_I(_s2_39));
               SET_COULEURS(NOIR,niveau_de_trace_du_squelette_niveau_1);
               gB;
               RCG(ACCES_CONTEXTE_I(_s2_18));
               SET_COULEURS(NOIR,niveau_de_trace_du_squelette_niveau_1);
               gB;

               CALS(FgMON());
               CALS(FgMOC());
               Eblock
          ATes
               Bblock
               Eblock
          ETes
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     SET_FILTRAGE(INACTIF);

     CALS(Imove(ImageR,ImageG));

     CALi(Iupdate_image(nom_imageR,ImageR));

     RETU_Commande;
     Eblock
ECommande



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