/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V I S U A L I S A T I O N   D ' U N E   C H A I N E   D E   C O N N E X I O N  :                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrv/particule.31$I' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 1997??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V I S U A L I S A T I O N   D ' U N E   C H A I N E   D E   C O N N E X I O N  :                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   AIDER_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                                                          \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(aider_a_la_mise_au_point_de__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION
                            ,AIDER_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION
                             )
                )
     );

#define   AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION(edition)                                                  \
                     Bblock                                                                                                             \
                     Test(IL_FAUT(aider_a_la_mise_au_point_de__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION))                                \
                          Bblock                                                                                                        \
                          BLOC(edition);                                                                                                \
                          Eblock                                                                                                        \
                     ATes                                                                                                               \
                          Bblock                                                                                                        \
                          Eblock                                                                                                        \
                     ETes                                                                                                               \
                     Eblock                                                                                                             \
                                        /* Introduit le 20230130124849 pour aider au choix des parametres...                         */

#define   COEFFICIENT_DE_LA_PENTE_X_DES_CHAINES_DE_CONNEXION                                                                            \
                     FZERO
#define   COEFFICIENT_DE_LA_PENTE_Y_DES_CHAINES_DE_CONNEXION                                                                            \
                     FZERO
#define   COEFFICIENT_DE_LA_PENTE_Z_DES_CHAINES_DE_CONNEXION                                                                            \
                     FZERO
#define   COEFFICIENT_DES_PENTE_XYZ_DES_CHAINES_DE_CONNEXION                                                                            \
                     FU
DEFV(Local,DEFV(Float,INIT(coefficient_de_la_pente_X_des_chaines_de_connexion,COEFFICIENT_DE_LA_PENTE_X_DES_CHAINES_DE_CONNEXION)));
DEFV(Local,DEFV(Float,INIT(coefficient_de_la_pente_Y_des_chaines_de_connexion,COEFFICIENT_DE_LA_PENTE_Y_DES_CHAINES_DE_CONNEXION)));
DEFV(Local,DEFV(Float,INIT(coefficient_de_la_pente_Z_des_chaines_de_connexion,COEFFICIENT_DE_LA_PENTE_Z_DES_CHAINES_DE_CONNEXION)));
DEFV(Local,DEFV(Float,INIT(coefficient_des_pente_XYZ_des_chaines_de_connexion,COEFFICIENT_DES_PENTE_XYZ_DES_CHAINES_DE_CONNEXION)));
                                        /* Introduit le 20180702094538 afin de pouvoir rendre "relatives" a la direction des         */
                                        /* connexions les definitions des splines eventuellement utilises...                         */

#define   GARANTIR_L_EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION                                                       \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion
                            ,GARANTIR_L_EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION
                             )
                )
     );
                                        /* Afin de garantir l'equidistance des points successifs d'une chaine de connexion. Ceci fut */
                                        /* introduit le 20051213135606 et la valeur par defaut garantit la compatibilite anterieure. */

#TestADef EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION_____COMPATIBILITE_20051230                                       \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(equidistance_des_points_successifs_d_une_chaine_de_connexion_____compatibilite_20051230
                            ,EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION_____COMPATIBILITE_20051230
                             )
                )
     );
                                        /* Afin d'assurer la compatibilite avec les resultats obtenus anterieurement a la date       */
                                        /* du 20051230130832...                                                                      */

#TestADef EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION_____COMPATIBILITE_20081109                                       \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(equidistance_des_points_successifs_d_une_chaine_de_connexion_____compatibilite_20081109
                            ,EQUIDISTANCE_DES_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION_____COMPATIBILITE_20081109
                             )
                )
     );
                                        /* Afin d'assurer la compatibilite avec les resultats obtenus anterieurement a la date       */
                                        /* du 20081109112831...                                                                      */

#TestADef GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS_____COMPATIBILITE_20250215                                                 \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(grossissement_du_rayon_de_visualisation_des_points_____compatibilite_20250215
                            ,GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS_____COMPATIBILITE_20250215
                             )
                )
     );
                                        /* Afin d'assurer la compatibilite avec les resultats obtenus anterieurement a la date       */
                                        /* du 20250215121531...                                                                      */

#define   DISTANCE_MINIMALE_ENTRE_DEUX_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION                                                      \
                     GRO5(FRA10(FRA10(FRA10(FU))))
DEFV(Local,DEFV(Float,INIT(distance_minimale_entre_deux_points_successifs_d_une_chaine_de_connexion
                          ,DISTANCE_MINIMALE_ENTRE_DEUX_POINTS_SUCCESSIFS_D_UNE_CHAINE_DE_CONNEXION
                           )
                )
     );
                                        /* Distance minimale entre deux points successifs d'une chaine de connexion. Ceci a ete      */
                                        /* introduit le 20051213092326. Le 20051213152707, la valeur par defaut est pasee de         */
                                        /* 'F_INFINI' a une valeur finie et pertinente...                                            */

#define   FACTEUR_D_AMELIORATION_DU_LAMBDA_D_UNE_CHAINE_DE_CONNEXION                                                                    \
                    FRA10(FU)
DEFV(Local,DEFV(Float,INIT(facteur_d_amelioration_du_lambda_d_une_chaine_de_connexion
                          ,FACTEUR_D_AMELIORATION_DU_LAMBDA_D_UNE_CHAINE_DE_CONNEXION
                           )
                )
     );
                                        /* Facteur permettant d'affiner 'lambda' de maniere iterative lorsque l'equidistance des     */
                                        /* points sucessifs est demandee...                                                          */

#define   LAMBDA_MINIMAL_D_UNE_CHAINE_DE_CONNEXION                                                                                      \
                    COORDONNEE_BARYCENTRIQUE_MINIMALE
#define   LAMBDA_MAXIMAL_D_UNE_CHAINE_DE_CONNEXION                                                                                      \
                    COORDONNEE_BARYCENTRIQUE_MAXIMALE
DEFV(Local,DEFV(Float,INIT(lambda_minimal_d_une_chaine_de_connexion,LAMBDA_MINIMAL_D_UNE_CHAINE_DE_CONNEXION)));
DEFV(Local,DEFV(Float,INIT(lambda_maximal_d_une_chaine_de_connexion,LAMBDA_MAXIMAL_D_UNE_CHAINE_DE_CONNEXION)));
                                        /* Afin de pouvoir limiter l'amplitude utilisee pour le 'lambda' d'interpolation ci-apres    */
                                        /* (introduit le 20010706161609) et ainsi pouvoir ne visualiser qu'une partie des points     */
                                        /* d'une chaine de connexion (par exemple reduite a un point comme cela est utilise dans     */
                                        /* 'v $xiird/.ACIN.A.11.$U Acinus_LambdaM').                                                 */

#define   INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES                                                                  \
                    VRAI
#define   NE_PAS_INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES                                                           \
                    NOTL(INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES)
DEFV(Local,DEFV(Logical,INIT(interpoler_les_chaines_de_connexion_par_des_splines_cubiques
                            ,NE_PAS_INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES
                             )
                )
     );
                                        /* Indique si l'on doit interpoler avec des splines cubiques ou simplement lineairement...   */

#ifndef   NE_PAS_GENERER_grossissement_du_rayon_de_visualisation_des_points
                                        /* Introduit le 20151207113023 pour 'v $xrc/Cfract_4D.11$K NE_PAS_GENERER_grossissement'...  */
#    TestADef  GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS                                                                       \
                         FU
DEFV(Local,DEFV(Float,INIT(grossissement_du_rayon_de_visualisation_des_points,GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS)));
                                        /* Facteur permettant de materialiser differemment les points d'extremite et les connexions. */
#    TestADef  EPSILON_DE_GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS                                                            \
                         mgEPSILON
DEFV(Local,DEFV(Float,INIT(epsilon_de_grossissement_du_rayon_de_visualisation_des_points
                          ,EPSILON_DE_GROSSISSEMENT_DU_RAYON_DE_VISUALISATION_DES_POINTS
                           )
                )
     );
                                        /* Introduit le 20250215121531 pour tenir compte des arrondis lors du choix de grossir       */
                                        /* le rayon ou pas...                                                                        */
#Aifndef  NE_PAS_GENERER_grossissement_du_rayon_de_visualisation_des_points
#Eifndef  NE_PAS_GENERER_grossissement_du_rayon_de_visualisation_des_points

#define   INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION                                                                               \
                    UN

#define   compatibilite_20051230_de_l_equidistance_des_points_successifs                                                                \
                    equidistance_des_points_successifs_d_une_chaine_de_connexion_____compatibilite_20051230                             \
                                        /* Afin de raccourcir la longueur de la ligne qui l'utilise...                               */

Denumer04(INIS(METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_NEUT,UN)
              ,METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_COSX
              ,METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_SINX
              ,METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_TANH
         ,methodes_de_modulation_du_lambda_des_derivees
          );
DEFV(Local,DEFV(Int,INIT(choix_de_la_methode_de_modulation_du_lambda_des_derivees,METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_NEUT)));
DEFV(Local,DEFV(Float,INIT(facteur_du_lambda_des_derivees,FU)));
DEFV(Local,DEFV(Float,INIT(translation_du_lambda_des_derivees,FZERO)));
DEFV(Local,DEFV(Float,INIT(facteur_modulation_du_lambda_des_derivees,FU)));
DEFV(Local,DEFV(Float,INIT(translation_modulation_du_lambda_des_derivees,FZERO)));
                                        /* Introduit le 20180528094155 afin de permettre la modulation du 'lambda' des derivees      */
                                        /* tout specialement pour 'v $xrv/particule.10$K VISUALISATION_D_UNE_CHAINE_DE_CONNEXION'    */
                                        /* lors de la mise au point des images du type 'v $xiird/NETW.33'...                         */

#define   MASSE_DES_POINTS_EXTREMES___D_UN_SEGMENT                                                                                      \
                    FLOT(EXIST)
#define   MASSE_DES_POINTS_INTERIEURS_D_UN_SEGMENT                                                                                      \
                    FLOT(NEXIST)
                                        /* Introduit le 20240519081857...                                                            */

#define   grossissement_rayon_visualisation_____compatibilite_20250215                                                                  \
                    grossissement_du_rayon_de_visualisation_des_points_____compatibilite_20250215
#define   epsilon_de_grossissement_rayon_visualisation                                                                                  \
                    epsilon_de_grossissement_du_rayon_de_visualisation_des_points
                                        /* Introduit le 20250215122855 afin de raccourcir quelques lignes a venir...                 */

#define   VISUALISATION_D_UNE_CHAINE_DE_CONNEXION(Ax,Ay,Az,Adcx,Adcy,Adcz,Ar,Bx,By,Bz,Bdcx,Bdcy,Bdcz,Br,Np,N,c,Adx,Ady,Adz,Bdx,Bdy,Bdz) \
                                        /* Le 20051213144859 l'argument 'n' a ete rebaptise 'N' car, en effet, le nom 'n'            */ \
                                        /* interferait malheureusement avec des chaines du type "\n" utilise dans des editions       */ \
                                        /* en phase de mise au point...                                                              */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : ne pas confondre {Adcx,Adcy,Adcz,Bdcx,Bdcy,Bdcz} qui concernent le coloriage  */ \
                                        /* et {Adx,Ady,Adz,Bdx,Bdy,Bdz} qui concernent les tangentes...                              */ \
                    Bblock                                                                                                              \
                    DEFV(Positive,INIT(compteur_des_points_memorises_pour_la_chaine_de_connexion_courante,ZERO));                       \
                                        /* Compteur introduit le 20230130124849 a des fins de validation...                          */ \
                    DEFV(Logical,INIT(la_construction_de_la_chaine_de_connexion_est_achevee,FAUX));                                     \
                    DEFV(Int,INIT(index_de_construction_de_la_chaine_de_connexion,INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION));    \
                                        /* Indicateurs de controle de la chaine de connexion...                                      */ \
                    DEFV(Float,INIT(EnTete_de_sauvegardM ## rayon_de_visualisation,rayon_de_visualisation));                            \
                                        /* Sauvegarde du rayon de visualisation avant sa modification. Ne pas le faire a des         */ \
                                        /* consequences graves dans le cas de la visualisation des axes au cas ou plusieurs          */ \
                                        /* images sont generees : pour les suivantes, le rayon de visualisation s'il n'est pas       */ \
                                        /* reinitialise se retrouve avec cette valeur...                                             */ \
                    DEFV(Float,INIT(Ar_local,Ar));                                                                                      \
                    DEFV(Float,INIT(Br_local,Br));                                                                                      \
                                        /* Memorisation locale des rayons {Ar,Br} au cas ou l'un ou l'autre aurait la mauvaise       */ \
                                        /* idee d'etre en fait 'rayon_de_visualisation' (defaut corrige le 20010510122057).          */ \
                    DEFV(Float,INIT(distance_minimale_effective_entre_deux_points_successifs                                            \
                                   ,COND(IL_FAUT(compatibilite_20051230_de_l_equidistance_des_points_successifs)                        \
                                        ,distance_minimale_entre_deux_points_successifs_d_une_chaine_de_connexion                       \
                                        ,DIVI(distance_minimale_entre_deux_points_successifs_d_une_chaine_de_connexion                  \
                                             ,rapport_courant_du_zoom                                                                   \
                                              )                                                                                         \
                                         )                                                                                              \
                                    )                                                                                                   \
                         );                                                                                                             \
                                        /* Petite optimisation introduite le 20230130155951...                                       */ \
                    DEFV(Float,INIT(c_x_precedent,FLOT__UNDEF));                                                                        \
                    DEFV(Float,INIT(c_y_precedent,FLOT__UNDEF));                                                                        \
                    DEFV(Float,INIT(c_z_precedent,FLOT__UNDEF));                                                                        \
                                        /* Coordonnees du point precedant le point courant {c_x,c_y,c_z} dans la chaine en           */ \
                                        /* construction (introduit le 20051213092326).                                               */ \
                    DEFV(Float,INIT(pas_de_lambda                                                                                       \
                                   ,DIVI(AMPLITUDE_DES_COORDONNEES_BARYCENTRIQUES                                                       \
                                        ,FLOT(SOUS(Np                                                                                   \
                                                  ,INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION                                      \
                                                   )                                                                                    \
                                              )                                                                                         \
                                         )                                                                                              \
                                    )                                                                                                   \
                         );                                                                                                             \
                    DEFV(Float,INIT(lambda_precedent,FLOT__UNDEF));                                                                     \
                    DEFV(Float,INIT(lambda,COORDONNEE_BARYCENTRIQUE_MINIMALE));                                                         \
                                        /* Parametre d'interpolation du point precedant le point courant, le pas ne servant que si   */ \
                                        /* 'IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion)'        */ \
                                        /*                                                                                           */ \
                                        /* Le 20230128141620, le 'INVE(...)' de la definition de 'pas_de_lambda' a ete remplace      */ \
                                        /* par 'DIVI(AMPLITUDE_DES_COORDONNEES_BARYCENTRIQUES,...)' qui est plus logique et donne    */ \
                                        /* evidemment le meme resultat...                                                            */ \
                                                                                                                                        \
                    Tant(EST_FAUX(la_construction_de_la_chaine_de_connexion_est_achevee))                                               \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion))                         \
                              Bblock                                                                                                    \
                              AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                                       \
                                  (                                                                                                     \
                                   Bblock                                                                                               \
                                   CAL2(Prin0("     Equidistance des points. "));                                                       \
                                   Eblock                                                                                               \
                                   );                                                                                                   \
                                                                                                                                        \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                                       \
                                  (                                                                                                     \
                                   Bblock                                                                                               \
                                   CAL2(Prin1("     NombreDePoints=%d ",Np));                                                           \
                                   Eblock                                                                                               \
                                   );                                                                                                   \
                                                                                                                                        \
                              EGAL(lambda                                                                                               \
                                  ,ADD2(COORDONNEE_BARYCENTRIQUE_MINIMALE                                                               \
                                       ,SCAL(FLOT(SOUS(index_de_construction_de_la_chaine_de_connexion                                  \
                                                      ,INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION                                  \
                                                       )                                                                                \
                                                  )                                                                                     \
                                            ,FLOT(SOUS(Np                                                                               \
                                                      ,INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION                                  \
                                                       )                                                                                \
                                                  )                                                                                     \
                                            ,SOUS(COORDONNEE_BARYCENTRIQUE_MAXIMALE                                                     \
                                                 ,COORDONNEE_BARYCENTRIQUE_MINIMALE                                                     \
                                                  )                                                                                     \
                                             )                                                                                          \
                                        )                                                                                               \
                                   );                                                                                                   \
                                        /* Definition de la coordonnee barycentrique d'interpolation des coordonnees et des          */ \
                                        /* couleurs des points de l'espace.                                                          */ \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                                            \
                             (                                                                                                          \
                              Bblock                                                                                                    \
                              CAL2(Prin1("Lambda=%f\n",lambda));                                                                        \
                              Eblock                                                                                                    \
                              );                                                                                                        \
                                                                                                                                        \
                         Test(IL_FAUT(equidistance_des_points_successifs_d_une_chaine_de_connexion_____compatibilite_20081109))         \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Test(IFEXff(lambda,COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE))                  \
                                        /* Ce test introduit le 20081109112831 est rendu necessaire par le mode                      */ \
                                        /* 'IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion)'        */ \
                                        /* a cause duquel 'lambda' peut aller au-dela de 'COORDONNEE_BARYCENTRIQUE_MAXIMALE'...      */ \
                                   Bblock                                                                                               \
                                   EGAL(lambda,TRON(lambda,COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE));       \
                                        /* Ce seuillage de 'lambda' garantit alors que l'extremite {Bx,By,Bz} de la chaine de        */ \
                                        /* connexion sera atteinte...                                                                */ \
                                        /*                                                                                           */ \
                                        /* Cela s'est vu a cette date lors de la generation de l'image 'v $xiirv/SURR.11'...         */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         Test(IFINff(lambda                                                                                             \
                                    ,lambda_minimal_d_une_chaine_de_connexion                                                           \
                                    ,COND(IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion)              \
                                         ,ADD2(lambda_maximal_d_une_chaine_de_connexion,pas_de_lambda)                                  \
                                         ,lambda_maximal_d_une_chaine_de_connexion                                                      \
                                          )                                                                                             \
                                     )                                                                                                  \
                              )                                                                                                         \
                              Bblock                                                                                                    \
                              DEFV(Logical,INIT(le_point_courant_est_connu,FAUX));                                                      \
                                        /* Afin de calculer le point courant...                                                      */ \
                              DEFV(Float,INIT(c_x,FLOT__UNDEF));                                                                        \
                              DEFV(Float,INIT(c_y,FLOT__UNDEF));                                                                        \
                              DEFV(Float,INIT(c_z,FLOT__UNDEF));                                                                        \
                                                                                                                                        \
                              DEFV(Float,INIT(dc_x,FLOT__UNDEF));                                                                       \
                              DEFV(Float,INIT(dc_y,FLOT__UNDEF));                                                                       \
                              DEFV(Float,INIT(dc_z,FLOT__UNDEF));                                                                       \
                                        /* Definition du point courant {c_x,c_y,c_z} et de sa couleur {dc_x,dc_y,dc_z}.              */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION, on notera que le 19991008092221, on est passe de {{cx,cy,cz},{dcx,dcy,dcz}}    */ \
                                        /* a {{c_x,c_y,c_z},{dc_x,dc_y,dc_z}} a cause de l'introduction de la procedure              */ \
                                        /* 'VISUALISATION_D_UN_SEGMENT_VARIABLE(...)' qui si 'IL_FAUT(generer_des_points_isoles)'    */ \
                                        /* est appelee avec comme argument {{cx,cy,cz},{dcx,dcy,dcz}}, variables qui existent donc   */ \
                                        /* a un autre niveau, d'ou un mechant probleme...                                            */ \
                                                                                                                                        \
                              Tant(EST_FAUX(le_point_courant_est_connu))                                                                \
                                        /* Ce dispositif a ete introduit le 20051213092326 afin de permettre d'ajuster localement    */ \
                                        /* l'interpolation sur une chaine de connexion ce qui garantit alors une distance presque    */ \
                                        /* constante entre deux points successifs...                                                 */ \
                                   Bblock                                                                                               \
                                   Test(IL_FAUT(c))                                                                                     \
                                        Bblock                                                                                          \
                                        DEFV(Float,INIT(Adx_effectif,Adx));                                                             \
                                        DEFV(Float,INIT(Ady_effectif,Ady));                                                             \
                                        DEFV(Float,INIT(Adz_effectif,Adz));                                                             \
                                        DEFV(Float,INIT(Bdx_effectif,Bdx));                                                             \
                                        DEFV(Float,INIT(Bdy_effectif,Bdy));                                                             \
                                        DEFV(Float,INIT(Bdz_effectif,Bdz));                                                             \
                                        /* Introduit le 20180702103601 afin d'alleger ce qui suit...                                 */ \
                                                                                                                                        \
                                        INCR(Adx_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_X_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteX_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        INCR(Ady_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_Y_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteY_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        INCR(Adz_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_Z_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteZ_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        INCR(Bdx_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_X_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteX_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        INCR(Bdy_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_Y_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteY_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        INCR(Bdz_effectif                                                                               \
                                            ,oAXPB(MUL2(coefficient_des_pente_XYZ_des_chaines_de_connexion                              \
                                                       ,coefficient_de_la_pente_Z_des_chaines_de_connexion                              \
                                                        )                                                                               \
                                                  ,PenteZ_normalisee_3D(Ax,Ay,Az,Bx,By,Bz)                                              \
                                                  ,FZERO                                                                                \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        /* Introduit le 20180702094538 afin de pouvoir rendre "relatives" a la direction des         */ \
                                        /* connexions les definitions des splines eventuellement utilises...                         */ \
                                                                                                                                        \
                                        EGAL(c_x,INTERPOLATION_CUBIQUE(Ax,Adx_effectif,Bx,Bdx_effectif,lambda));                        \
                                        EGAL(c_y,INTERPOLATION_CUBIQUE(Ay,Ady_effectif,By,Bdy_effectif,lambda));                        \
                                        EGAL(c_z,INTERPOLATION_CUBIQUE(Az,Adz_effectif,Bz,Bdz_effectif,lambda));                        \
                                        /* Recuperation de la position du point courant (c_x,c_y,c_z) par interpolation cubique...   */ \
                                        /*                                                                                           */ \
                                        /* Le 20231012102900 grace a 'v $xiirv/SMIT.91' je note que le processus precedent ne        */ \
                                        /* fonctionne pas correctement si, en deux dimensions, la pente du segment AB est egale      */ \
                                        /* a 1. Cela a ete teste en tracant le segment {{0.1,0.1}.{0.9,0.9}} et en editant les       */ \
                                        /* valeurs des coefficients 'INTERPOLATION_CUBIQUE_t3?(...)' pour les coordonnees 'c_x'      */ \
                                        /* et 'c_y'. Avec les valeurs (arbitraires, mais non nulles evidemment) :                    */ \
                                        /*                                                                                           */ \
                                        /*                  LISTE_dX=0.5                                                             */ \
                                        /*                  LISTE_dY=0.5                                                             */ \
                                        /*                                                                                           */ \
                                        /* on obtient lors du calcul des coordonnees 'x' et 'y' des 16 points, malheureusement,      */ \
                                        /* les memes valeurs :                                                                       */ \
                                        /*                                                                                           */ \
                                        /*                  t3x=-2.2000         t2x=3.3000          t1x=0.5000          t0x=-0.8000  */ \
                                        /*                  t3y=-2.2000         t2y=3.3000          t1y=0.5000          t0y=-0.8000  */ \
                                        /*                                                                                           */ \
                                        /* L'interpolation est donc strictement la meme sur les deux axes (voire les trois si l'on   */ \
                                        /* avait ete dans un test tridimensionnel), ce qui fait que tous les points interpoles       */ \
                                        /* restent sur le segment {{0.1,0.1}.{0.9,0.9}} au lieu d'onduler de part et d'autre,        */ \
                                        /* comme on l'esperait...                                                                    */ \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        EGAL(c_x,INTERPOLATION_LINEAIRE(Ax,Bx,lambda));                                                 \
                                        EGAL(c_y,INTERPOLATION_LINEAIRE(Ay,By,lambda));                                                 \
                                        EGAL(c_z,INTERPOLATION_LINEAIRE(Az,Bz,lambda));                                                 \
                                        /* Recuperation de la position du point courant (c_x,c_y,c_z) par interpolation lineaire...  */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                                                                                                                        \
                                   Test(IFET(IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion)           \
                                            ,IFGT(index_de_construction_de_la_chaine_de_connexion                                       \
                                                 ,INDEX_DE_CONSTRUCTION_DE_LA_CHAINE_DE_CONNEXION                                       \
                                                  )                                                                                     \
                                             )                                                                                          \
                                        )                                                                                               \
                                        Bblock                                                                                          \
                                        /* Cas des points suivants lorsqu'il faut garantir l'equidistance des points successifs :    */ \
                                        AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                             \
                                            (                                                                                           \
                                             Bblock                                                                                     \
                                             CAL2(Prin7("     DistanceCourante{{%f,%f,%f},{%f,%f,%f}}=%f "                              \
                                                       ,c_x,c_y,c_z                                                                     \
                                                       ,c_x_precedent,c_y_precedent,c_z_precedent                                       \
                                                       ,RdisF3D(c_x,c_y,c_z                                                             \
                                                               ,c_x_precedent,c_y_precedent,c_z_precedent                               \
                                                                )                                                                       \
                                                        )                                                                               \
                                                  );                                                                                    \
                                             CAL2(Prin1("DistanceMinimaleEffective=%f\n"                                                \
                                                       ,distance_minimale_effective_entre_deux_points_successifs                        \
                                                        )                                                                               \
                                                  );                                                                                    \
                                             Eblock                                                                                     \
                                             );                                                                                         \
                                                                                                                                        \
                                        Test(IFLE(RdisF3D(c_x,c_y,c_z                                                                   \
                                                         ,c_x_precedent,c_y_precedent,c_z_precedent                                     \
                                                          )                                                                             \
                                                 ,distance_minimale_effective_entre_deux_points_successifs                              \
                                                  )                                                                                     \
                                             )                                                                                          \
                                             Bblock                                                                                     \
                                             EGAL(le_point_courant_est_connu,VRAI);                                                     \
                                        /* Le point courant est suffisamment pres du point precedent : on s'arrete...                */ \
                                             Eblock                                                                                     \
                                        ATes                                                                                            \
                                             Bblock                                                                                     \
                                             DECR(lambda                                                                                \
                                                 ,MUL2(facteur_d_amelioration_du_lambda_d_une_chaine_de_connexion                       \
                                                      ,SOUS(lambda,lambda_precedent)                                                    \
                                                       )                                                                                \
                                                  );                                                                                    \
                                        /* Et reduction du parametre d'interpolation...                                              */ \
                                        /*                                                                                           */ \
                                        /* Le 20160321145415, de nombreuses experiences furent effectuees afin de comprendre         */ \
                                        /* pourquoi si 'IL_FAUT(c)' le 'rayon_de_visualisation', bien qu'interpole a l'aide de       */ \
                                        /* 'INTERPOLATION_LINEAIRE(...)' variait de facon "non lineaire". L'explication est la       */ \
                                        /* suivante : cette interpolation lineaire est controlee par le parametre 'lambda'. Or       */ \
                                        /* celui-ci est ajuste en permanence grace a 'INTERPOLATION_CUBIQUE(...)' via les            */ \
                                        /* coordonnees du point courant {c_x,c_y,c_z} et celles du point precedent. Ainsi, par       */ \
                                        /* exemple, pour interpoler entre les points {0,-1,0} et {0,0,0} avec des derivees nulles,   */ \
                                        /* voici les differences antre les 'lambdas' calcules successifs (en n'en gardant qu'un      */ \
                                        /* sur dix parmi 179) :                                                                      */ \
                                        /*                                                                                           */ \
                                        /*                  +0.043047      <--  Grosses                                              */ \
                                        /*                  +0.007179      <--          differences,                                 */ \
                                        /*                  +0.005234                                                                */ \
                                        /*                  +0.004710                                                                */ \
                                        /*                  +0.004239                                                                */ \
                                        /*                  +0.003815      -                                                         */ \
                                        /*                  +0.003815       |                                                        */ \
                                        /*                  +0.003815       |                                                        */ \
                                        /*                  +0.003816       |   Differences quasiment constantes,                    */ \
                                        /*                  +0.003815       |                                                        */ \
                                        /*                  +0.003815       |                                                        */ \
                                        /*                  +0.003815      -                                                         */ \
                                        /*                  +0.004239                                                                */ \
                                        /*                  +0.004710                                                                */ \
                                        /*                  +0.005233                                                                */ \
                                        /*                  +0.006461                                                                */ \
                                        /*                  +0.014110      <--  Grosses                                              */ \
                                        /*                  +0.042568      <--          differences.                                 */ \
                                        /*                                                                                           */ \
                                        /* Les variations sont donc assez brutales, en particulier aux extremites. C'est cela qui    */ \
                                        /* explique les variations "ennuyeuses" du rayon lorsqu'il est calcule grace a ce 'lambda'.  */ \
                                                                                                                                        \
                                             AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                        \
                                                 (                                                                                      \
                                                  Bblock                                                                                \
                                                  CAL2(Prin1("     Lambda=%f\n"                                                         \
                                                            ,lambda                                                                     \
                                                             )                                                                          \
                                                       );                                                                               \
                                                  Eblock                                                                                \
                                                  );                                                                                    \
                                             Eblock                                                                                     \
                                        ETes                                                                                            \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        EGAL(le_point_courant_est_connu,VRAI);                                                          \
                                        /* Cas du premier point : on s'arrete immediatement...                                       */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                              ETan                                                                                                      \
                                                                                                                                        \
                              Test(IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion))                    \
                                   Bblock                                                                                               \
                                   EGAL(lambda_precedent,lambda);                                                                       \
                                        /* Et son parametre d'interpolation...                                                       */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                                                                                                                                        \
                              Test(IFLE(lambda,COORDONNEE_BARYCENTRIQUE_MAXIMALE))                                                      \
                                        /* Ce test introduit le 20051213143437 est rendu necessaire par le mode                      */ \
                                        /* 'IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion)'        */ \
                                        /* a cause duquel 'lambda' peut aller au-dela de 'COORDONNEE_BARYCENTRIQUE_MAXIMALE'...      */ \
                                   Bblock                                                                                               \
                                   EGAL(c_x_precedent,c_x);                                                                             \
                                   EGAL(c_y_precedent,c_y);                                                                             \
                                   EGAL(c_z_precedent,c_z);                                                                             \
                                        /* Et on memorise le futur point precedent...                                                */ \
                                                                                                                                        \
                                   begin_nouveau_block                                                                                  \
                                        Bblock                                                                                          \
                                        DEFV(Float,INIT(lambda_des_derivees_avant_modulation                                            \
                                                       ,AXPB(facteur_du_lambda_des_derivees,lambda,translation_du_lambda_des_derivees)  \
                                                        )                                                                               \
                                             );                                                                                         \
                                        DEFV(Float,INIT(lambda_des_derivees_apres_modulation,lambda));                                  \
                                        /* Par defaut au cas ou la mothode de modulation ne serait pas reconnue...                   */ \
                                                                                                                                        \
                                        Choi(choix_de_la_methode_de_modulation_du_lambda_des_derivees)                                  \
                                             Bblock                                                                                     \
                                             Ca1e(METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_NEUT)                                    \
                                                  Bblock                                                                                \
                                                  EGAL(lambda_des_derivees_apres_modulation                                             \
                                                      ,NEUT(lambda_des_derivees_avant_modulation)                                       \
                                                       );                                                                               \
                                                  Eblock                                                                                \
                                             ECa1                                                                                       \
                                                                                                                                        \
                                             Ca1e(METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_COSX)                                    \
                                                  Bblock                                                                                \
                                                  EGAL(lambda_des_derivees_apres_modulation                                             \
                                                      ,COSX(lambda_des_derivees_avant_modulation)                                       \
                                                       );                                                                               \
                                                  Eblock                                                                                \
                                             ECa1                                                                                       \
                                                                                                                                        \
                                             Ca1e(METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_SINX)                                    \
                                                  Bblock                                                                                \
                                                  EGAL(lambda_des_derivees_apres_modulation                                             \
                                                      ,SINX(lambda_des_derivees_avant_modulation)                                       \
                                                       );                                                                               \
                                                  Eblock                                                                                \
                                             ECa1                                                                                       \
                                                                                                                                        \
                                             Ca1e(METHODE_DE_MODULATION_DU_LAMBDA_DES_DERIVEES_TANH)                                    \
                                                  Bblock                                                                                \
                                                  EGAL(lambda_des_derivees_apres_modulation                                             \
                                                      ,TANH(lambda_des_derivees_avant_modulation)                                       \
                                                       );                                                                               \
                                                  Eblock                                                                                \
                                             ECa1                                                                                       \
                                                                                                                                        \
                                             Defo                                                                                       \
                                                  Bblock                                                                                \
                                                  PRINT_ERREUR("la methode de modulation du 'lambda' des derivees n'est pas reconnue"); \
                                                  Eblock                                                                                \
                                             EDef                                                                                       \
                                             Eblock                                                                                     \
                                        ECho                                                                                            \
                                                                                                                                        \
                                        EGAL(lambda_des_derivees_apres_modulation                                                       \
                                            ,AXPB(facteur_modulation_du_lambda_des_derivees                                             \
                                                 ,lambda_des_derivees_apres_modulation                                                  \
                                                 ,translation_modulation_du_lambda_des_derivees                                         \
                                                  )                                                                                     \
                                             );                                                                                         \
                                        /* Cette possibilite de moduler "lambda" a ete introduite le 20180528094155...               */ \
                                        /*                                                                                           */ \
                                        /* Les fonctions utilisees ci-dessus (a l'exception evidemment de 'NEUT(...) renvoient       */ \
                                        /* des valeurs dans [-1,+1]. On devra donc en general choisir :                              */ \
                                        /*                                                                                           */ \
                                        /*                  facteur_modulation_du_lambda_des_derivees     = +1/2                     */ \
                                        /*                  translation_modulation_du_lambda_des_derivees = +1/2                     */ \
                                        /*                                                                                           */ \
                                        /* pour revenir a un 'lambda' dans [0,1] avec en general au prealable :                      */ \
                                        /*                                                                                           */ \
                                        /*                  facteur_modulation_du_lambda_des_derivees     = +2                       */ \
                                        /*                  translation_modulation_du_lambda_des_derivees = -1                       */ \
                                        /*                                                                                           */ \
                                        /* pour amener le 'lambda' dans [-1,+1]...                                                   */ \
                                                                                                                                        \
                                        EGAL(dc_x,INTERPOLATION_LINEAIRE(Adcx,Bdcx,lambda_des_derivees_apres_modulation));              \
                                        EGAL(dc_y,INTERPOLATION_LINEAIRE(Adcy,Bdcy,lambda_des_derivees_apres_modulation));              \
                                        EGAL(dc_z,INTERPOLATION_LINEAIRE(Adcz,Bdcz,lambda_des_derivees_apres_modulation));              \
                                        /* Forcage arbitraire des derivees (dc_x,dc_y,dc_z) au point courant.                        */ \
                                        Eblock                                                                                          \
                                   end_nouveau_block                                                                                    \
                                                                                                                                        \
                                   EGAL(rayon_de_visualisation,INTERPOLATION_LINEAIRE(Ar_local,Br_local,lambda));                       \
                                        /* Et calcul du rayon de visualisation. ATTENTION, 'rayon_de_visualisation' ne peut          */ \
                                        /* etre une variable locale parce qu'elle est transmise "globalement" a la fonction          */ \
                                        /* 'memorisation_1_point_07(...)'.                                                           */ \
                                                                                                                                        \
                                   Test(IFOU(IFOU(IFET(IL_FAUT(grossissement_rayon_visualisation_____compatibilite_20250215)            \
                                                      ,IFOU(I3ET(IFEQ(c_x,Ax),IFEQ(c_y,Ay),IFEQ(c_z,Az))                                \
                                                           ,I3ET(IFEQ(c_x,Bx),IFEQ(c_y,By),IFEQ(c_z,Bz))                                \
                                                            )                                                                           \
                                                       )                                                                                \
                                                 ,IFET(IL_NE_FAUT_PAS(grossissement_rayon_visualisation_____compatibilite_20250215)     \
                                                      ,IFOU(I3ET(IFEQ_a_peu_pres_absolu(c_x,Ax                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                ,IFEQ_a_peu_pres_absolu(c_y,Ay                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                ,IFEQ_a_peu_pres_absolu(c_z,Az                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                 )                                                                      \
                                                           ,I3ET(IFEQ_a_peu_pres_absolu(c_x,Bx                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                ,IFEQ_a_peu_pres_absolu(c_y,By                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                ,IFEQ_a_peu_pres_absolu(c_z,Bz                                          \
                                                                                       ,epsilon_de_grossissement_rayon_visualisation    \
                                                                                        )                                               \
                                                                 )                                                                      \
                                                            )                                                                           \
                                                       )                                                                                \
                                                  )                                                                                     \
                                            ,IFGE(lambda,COORDONNEE_BARYCENTRIQUE_MAXIMALE)                                             \
                                             )                                                                                          \
                                        )                                                                                               \
                                        /* Le test concernant 'lambda' par rapport a sa valeur maximale a ete introduit le           */ \
                                        /* 20130419141837 car, en effet, il manquait. Il est necessaire car rien ne prouve que       */ \
                                        /* {c_x,c_y,c_z} atteigne exactement {Bx,By,Bz}, en particulier depuis qu'a ete introduite   */ \
                                        /* l'equidistance des points...                                                              */ \
                                        /*                                                                                           */ \
                                        /* L'introduction de "epsilon" a ete faite le 20250215121531, lors de la definition de       */ \
                                        /* 'v $xiirv/LEGE.11' avec '_____Rayon=0.005' et '_____NombreIntervalles=19' pour laquelle   */ \
                                        /* il manquait quelques "boules superieures" (la premiere pour 'index=7')...                 */ \
                                        Bblock                                                                                          \
                                        EGAL(rayon_de_visualisation                                                                     \
                                            ,MUL2(grossissement_du_rayon_de_visualisation_des_points,rayon_de_visualisation)            \
                                             );                                                                                         \
                                        EGAL(masse_de_la_sphere_courante,MASSE_DES_POINTS_EXTREMES___D_UN_SEGMENT);                     \
                                        /* Introduit le 20240519081857 pour transmission "hors-arguments" a la fonction              */ \
                                        /* 'memorisation_1_point_07(...)'.                                                           */ \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        EGAL(masse_de_la_sphere_courante,MASSE_DES_POINTS_INTERIEURS_D_UN_SEGMENT);                     \
                                        /* Introduit le 20240519081857 pour transmission "hors-arguments" a la fonction              */ \
                                        /* 'memorisation_1_point_07(...)'.                                                           */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                                                                                                                        \
                                   INCR(compteur_des_points_memorises_pour_la_chaine_de_connexion_courante,I);                          \
                                                                                                                                        \
                                   AIDE_A_LA_MISE_AU_POINT_DE__VISUALISATION_D_UNE_CHAINE_DE_CONNEXION                                  \
                                       (                                                                                                \
                                        Bblock                                                                                          \
                                        CAL2(Prin4("Memorisation du point courant(%d)={%f,%f,%f}.\n"                                    \
                                                  ,c_x,c_y,c_z                                                                          \
                                                  ,compteur_des_points_memorises_pour_la_chaine_de_connexion_courante                   \
                                                   )                                                                                    \
                                             );                                                                                         \
                                        Eblock                                                                                          \
                                        );                                                                                              \
                                                                                                                                        \
                                   CALS(memorisation_1_point_07(SOUS(c_x,Xcentre_ESPACE)                                                \
                                                               ,SOUS(c_y,Ycentre_ESPACE)                                                \
                                                               ,SOUS(c_z,Zcentre_ESPACE)                                                \
                                                               ,dc_x                                                                    \
                                                               ,dc_y                                                                    \
                                                               ,dc_z                                                                    \
                                                               ,N                                                                       \
                                                                )                                                                       \
                                        );                                                                                              \
                                        /* Memorisation du point courant d'une chaine de materialisation d'un couple de points.      */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         INCR(index_de_construction_de_la_chaine_de_connexion,I);                                                       \
                                        /* Progression de l'index de construction... ATTENTION : cette incrementation doit etre      */ \
                                        /* faite meme si l'on garantit la distance entre les points successifs car, en effet, cet    */ \
                                        /* index est utilise pour differencier le premier point des autres dans ce cas...            */ \
                                                                                                                                        \
                         Test(IL_FAUT(garantir_l_equidistance_des_points_successifs_d_une_chaine_de_connexion))                         \
                              Bblock                                                                                                    \
                              INCR(lambda,pas_de_lambda);                                                                               \
                                        /* Progression du lambda...                                                                  */ \
                                                                                                                                        \
                              Test(IFGE(lambda,ADD2(COORDONNEE_BARYCENTRIQUE_MAXIMALE,pas_de_lambda)))                                  \
                                   Bblock                                                                                               \
                                   EGAL(la_construction_de_la_chaine_de_connexion_est_achevee,VRAI);                                    \
                                        /* La construction de la chaine de connexion est achevee...                                  */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Test(IFGT(index_de_construction_de_la_chaine_de_connexion                                                 \
                                       ,COND(I3ET(I3ET(IFEQ(Ax,Bx)                                                                      \
                                                      ,IFEQ(Ay,By)                                                                      \
                                                      ,IFEQ(Az,Bz)                                                                      \
                                                       )                                                                                \
                                                 ,I3ET(IFEQ(Adcx,Bdcx)                                                                  \
                                                      ,IFEQ(Adcy,Bdcy)                                                                  \
                                                      ,IFEQ(Adcz,Bdcz)                                                                  \
                                                       )                                                                                \
                                                 ,IFEQ(Ar_local,Br_local)                                                               \
                                                  )                                                                                     \
                                            ,UN                                                                                         \
                                            ,Np                                                                                         \
                                             )                                                                                          \
                                        )                                                                                               \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                   EGAL(la_construction_de_la_chaine_de_connexion_est_achevee,VRAI);                                    \
                                        /* La construction de la chaine de connexion est achevee...                                  */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ETan                                                                                                                \
                                                                                                                                        \
                    EGAL(rayon_de_visualisation,EnTete_de_sauvegardM ## rayon_de_visualisation);                                        \
                                        /* Restauration du rayon de visualisation...                                                 */ \
                    Eblock                                                                                                              \
                                        /* Visualisation d'une chaine de points connectant le point 'A' au point 'B'.                */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V I S U A L I S A T I O N   D E S   A X E S  :                                                                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*             *     * * * * * *   * * * * * *   * * * * * *   *         *   * * * * * *   *   * * * * * *   *         *             */
/*                        *             *        *             **        *        *        *   *         *   **        *             */
/*            * *         *             *        *             * *       *        *        *   *         *   * *       *             */
/*                        *             *        *             *  *      *        *        *   *         *   *  *      *             */
/*           *   *        *             *        *             *   *     *        *        *   *         *   *   *     *             */
/*                        *             *        * * *         *    *    *        *        *   *         *   *    *    *             */
/*          * * * *       *             *        *             *     *   *        *        *   *         *   *     *   *             */
/*                        *             *        *             *      *  *        *        *   *         *   *      *  *             */
/*         *       *      *             *        *             *       * *        *        *   *         *   *       * *             */
/*                        *             *        *             *        **        *        *   *         *   *        **             */
/*        *         *     *             *        * * * * * *   *         *        *        *   * * * * * *   *         *             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        ATTENTION :                                                                                                                */
/*                                                                                                                                   */
/*                    Lors de l'utilisation d'echelles non lineaires pour les coordonnees                                            */
/*                  via 'IL_NE_FAUT_PAS(prendre_une_echelle_lineaire_pour_les_coordonnees)'                                          */
/*                  dans 'v $rxv/champs_5.26$I' (ce qui se produit en general avec le                                                */
/*                  programme 'v $xrr/N_corps.11$K'), les spheres materialisant les                                                  */
/*                  axes subissent elles-aussi cette transformation ; elles ne sont                                                  */
/*                  alors pas equi-reparties...                                                                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Couleurs implicites des axes :                                                                                             */
/*                                                                                                                                   */
/*                    Sauf modification lors de l'appel des                                                                          */
/*                  programmes correspondants, la couleur                                                                            */
/*                  implicite des axes est :                                                                                         */
/*                                                                                                                                   */
/*                                      OX        ROUGE                                                                              */
/*                                      OY        VERTE                                                                              */
/*                                      OZ        BLEUE                                                                              */
/*                                                                                                                                   */
/*                  C'est-a-dire l'ordre logique {R,V,B}={X,Y,Z}.                                                                    */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   VISUALISER_LES_AXES_DE_COORDONNEES                                                                                            \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(visualiser_les_axes_de_coordonnees,VISUALISER_LES_AXES_DE_COORDONNEES)));
                                        /* Indique si l'on visualise les axes de coordonnees ('VRAI') ou pas ('FAUX').               */
#define   VISUALISER_LA_PARTIE_NEGATIVE_DES_AXES_DE_COORDONNEES                                                                         \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(visualiser_la_partie_negative_des_axes_de_coordonnees
                            ,VISUALISER_LA_PARTIE_NEGATIVE_DES_AXES_DE_COORDONNEES
                             )
                )
     );
                                        /* Indique si l'on visualise uniquement la partie positive ('FAUX') des axes de coordonnees  */
                                        /* ou de plus leur partie negative ('VRAI').                                                 */

#define   LONGUEUR_DES_AXES_DE_COORDONNEES                                                                                              \
                    FRA1(FRA4(mhXYZlongueur_ESPACE))
DEFV(Local,DEFV(Float,INIT(longueur_des_axes_de_coordonnees,LONGUEUR_DES_AXES_DE_COORDONNEES)));

#define   RAYON_DE_L_ORIGINE_DES_AXES_DE_COORDONNEES                                                                                    \
                    FRA1(FRA10(FRA10(mhXYZlongueur_ESPACE)))
#define   RAYON_DE_L_EXTREMITE_DES_AXES_DE_COORDONNEES                                                                                  \
                    FRA2(FRA10(FRA10(mhXYZlongueur_ESPACE)))
DEFV(Local,DEFV(Float,INIT(rayon_de_l_origine_des_axes_de_coordonnees,RAYON_DE_L_ORIGINE_DES_AXES_DE_COORDONNEES)));
DEFV(Local,DEFV(Float,INIT(rayon_de_l_extremite_des_axes_de_coordonnees,RAYON_DE_L_EXTREMITE_DES_AXES_DE_COORDONNEES)));
                                        /* Definition de la geometrie des 3 axes. ATTENTION, il est impossible d'utiliser la         */
                                        /* valeur de 'mXYZlongueur_ESPACE' a la place de 'mhXYZlongueur_ESPACE' car, en effet,       */
                                        /* est imperatif d'avoir ici une constante...                                                */

#define   NOMBRE_DE_POINTS_DES_AXES_DE_COORDONNEES                                                                                      \
                    CENT
DEFV(Local,DEFV(Int,INIT(nombre_de_points_des_axes_de_coordonnees,NOMBRE_DE_POINTS_DES_AXES_DE_COORDONNEES)));
                                        /* Nombre de points utilises pour visualiser chacun des axes de coordonnees.                 */

#define   LA_COULEUR_ORIGINE_EST_COMMUNE_A_XYZ                                                                                          \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(la_couleur_origine_est_commune_a_XYZ,LA_COULEUR_ORIGINE_EST_COMMUNE_A_XYZ)));
                                        /* Le 20091024183153 fut introduit le fait que la couleur de l'origine puisse ne plus        */
                                        /* etre la meme sur les trois axes. La valeur par defaut ('VRAI') garantit la compatibilite  */
                                        /* anterieure...                                                                             */

#define   NIVEAU_DE_ROUGE_DE_L_ORIGINE_DES_AXES                                                                                         \
                    BLANC
#define   NIVEAU_DE_VERTE_DE_L_ORIGINE_DES_AXES                                                                                         \
                    BLANC
#define   NIVEAU_DE_BLEUE_DE_L_ORIGINE_DES_AXES                                                                                         \
                    BLANC
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_origine_des_axes,NIVEAU_DE_ROUGE_DE_L_ORIGINE_DES_AXES)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_origine_des_axes,NIVEAU_DE_VERTE_DE_L_ORIGINE_DES_AXES)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_origine_des_axes,NIVEAU_DE_BLEUE_DE_L_ORIGINE_DES_AXES)));
                                        /* Definition de la couleur de l'origine des 3 axes.                                         */

#define   NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OX                                                                                      \
                    BLANC
#define   NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OX                                                                                      \
                    NOIR
#define   NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OX                                                                                      \
                    NOIR
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_origine_de_l_axe_OX,NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OX)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_origine_de_l_axe_OX,NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OX)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_origine_de_l_axe_OX,NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OX)));
                                        /* Definition de la couleur de l'origine de l'axe 'OX' ('ROUGE' implicite).                  */

#define   NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OY                                                                                      \
                    NOIR
#define   NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OY                                                                                      \
                    BLANC
#define   NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OY                                                                                      \
                    NOIR
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_origine_de_l_axe_OY,NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OY)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_origine_de_l_axe_OY,NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OY)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_origine_de_l_axe_OY,NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OY)));
                                        /* Definition de la couleur de l'origine de l'axe 'OY' ('VERTE' implicite).                  */

#define   NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OZ                                                                                      \
                    NOIR
#define   NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OZ                                                                                      \
                    NOIR
#define   NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OZ                                                                                      \
                    BLANC
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_origine_de_l_axe_OZ,NIVEAU_DE_ROUGE_DE_L_ORIGINE_DE_L_AXE_OZ)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_origine_de_l_axe_OZ,NIVEAU_DE_VERTE_DE_L_ORIGINE_DE_L_AXE_OZ)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_origine_de_l_axe_OZ,NIVEAU_DE_BLEUE_DE_L_ORIGINE_DE_L_AXE_OZ)));
                                        /* Definition de la couleur de l'origine de l'axe 'OZ' ('BLEUE' implicite).                  */

#define   NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OX                                                                                    \
                    BLANC
#define   NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OX                                                                                    \
                    NOIR
#define   NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OX                                                                                    \
                    NOIR
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_extremite_de_l_axe_OX,NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OX)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_extremite_de_l_axe_OX,NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OX)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_extremite_de_l_axe_OX,NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OX)));
                                        /* Definition de la couleur de l'extremite de l'axe 'OX' ('ROUGE' implicite).                */

#define   NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OY                                                                                    \
                    NOIR
#define   NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OY                                                                                    \
                    BLANC
#define   NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OY                                                                                    \
                    NOIR
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_extremite_de_l_axe_OY,NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OY)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_extremite_de_l_axe_OY,NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OY)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_extremite_de_l_axe_OY,NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OY)));
                                        /* Definition de la couleur de l'extremite de l'axe 'OY' ('VERTE' implicite).                */

#define   NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OZ                                                                                    \
                    NOIR
#define   NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OZ                                                                                    \
                    NOIR
#define   NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OZ                                                                                    \
                    BLANC
DEFV(Local,DEFV(genere_p,INIT(niveau_de_ROUGE_de_l_extremite_de_l_axe_OZ,NIVEAU_DE_ROUGE_DE_L_EXTREMITE_DE_L_AXE_OZ)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_VERTE_de_l_extremite_de_l_axe_OZ,NIVEAU_DE_VERTE_DE_L_EXTREMITE_DE_L_AXE_OZ)));
DEFV(Local,DEFV(genere_p,INIT(niveau_de_BLEUE_de_l_extremite_de_l_axe_OZ,NIVEAU_DE_BLEUE_DE_L_EXTREMITE_DE_L_AXE_OZ)));
                                        /* Definition de la couleur de l'extremite de l'axe 'OZ' ('BLEUE' implicite).                */

#define   NIVEAU_DERIVEE_X(niveau)                                                                                                      \
                    X_DERIVEE_DENORMALISEE(______NORMALISE_NIVEAU(niveau))
#define   NIVEAU_DERIVEE_Y(niveau)                                                                                                      \
                    Y_DERIVEE_DENORMALISEE(______NORMALISE_NIVEAU(niveau))
#define   NIVEAU_DERIVEE_Z(niveau)                                                                                                      \
                    Z_DERIVEE_DENORMALISEE(______NORMALISE_NIVEAU(niveau))
                                        /* Formules de passages des niveaux aux derivees dans le bon segment (elles sont destinees   */
                                        /* en fait a ne pas allonger la longueur des lignes ci-apres...).                            */

#define   XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(coordonnee,longueur)                                                                      \
                    COND(IL_NE_FAUT_PAS(visualiser_la_partie_negative_des_axes_de_coordonnees)                                          \
                        ,coordonnee                                                                                                     \
                        ,SOUS(coordonnee,longueur)                                                                                      \
                         )
#define   XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(coordonnee,longueur)                                                                    \
                    ADD2(coordonnee,longueur)
#define   NOMBRE_EFFECTIF_DE_POINTS_DES_AXES_DE_COORDONNEES                                                                             \
                    COND(IL_NE_FAUT_PAS(visualiser_la_partie_negative_des_axes_de_coordonnees)                                          \
                        ,nombre_de_points_des_axes_de_coordonnees                                                                       \
                        ,DOUP(nombre_de_points_des_axes_de_coordonnees)                                                                 \
                         )
                                        /* Gestion des extremites des axes de coordonnees...                                         */

#define   gVISUALISATION_DES_AXES_DE_COORDONNEES                                                                                        \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(visualiser_les_axes_de_coordonnees))                                                                   \
                         Bblock                                                                                                         \
                         VISUALISATION_D_UNE_CHAINE_DE_CONNEXION(XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FXorigine                          \
                                                                                                    ,longueur_des_axes_de_coordonnees   \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FYorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FZorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,NIVEAU_DERIVEE_X(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_ROUGE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_ROUGE_de_l_origine_de_l_axe_OX         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Y(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_VERTE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_VERTE_de_l_origine_de_l_axe_OX         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Z(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_BLEUE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_BLEUE_de_l_origine_de_l_axe_OX         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,rayon_de_l_origine_des_axes_de_coordonnees                             \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FXorigine                        \
                                                                                                      ,longueur_des_axes_de_coordonnees \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FYorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FZorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,NIVEAU_DERIVEE_X(niveau_de_ROUGE_de_l_extremite_de_l_axe_OX)           \
                                                                ,NIVEAU_DERIVEE_Y(niveau_de_VERTE_de_l_extremite_de_l_axe_OX)           \
                                                                ,NIVEAU_DERIVEE_Z(niveau_de_BLEUE_de_l_extremite_de_l_axe_OX)           \
                                                                ,rayon_de_l_extremite_des_axes_de_coordonnees                           \
                                                                ,NOMBRE_EFFECTIF_DE_POINTS_DES_AXES_DE_COORDONNEES                      \
                                                                ,DERNIERE_ITERATION_VISUALISEE                                          \
                                                                ,NE_PAS_INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES    \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                 );                                                                     \
                                        /* Visualisation de l'axe 'OX'.                                                              */ \
                         VISUALISATION_D_UNE_CHAINE_DE_CONNEXION(XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FXorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FYorigine                          \
                                                                                                    ,longueur_des_axes_de_coordonnees   \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FZorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,NIVEAU_DERIVEE_X(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_ROUGE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_ROUGE_de_l_origine_de_l_axe_OY         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Y(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_VERTE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_VERTE_de_l_origine_de_l_axe_OY         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Z(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_BLEUE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_BLEUE_de_l_origine_de_l_axe_OY         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,rayon_de_l_origine_des_axes_de_coordonnees                             \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FXorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FYorigine                        \
                                                                                                      ,longueur_des_axes_de_coordonnees \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FZorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,NIVEAU_DERIVEE_X(niveau_de_ROUGE_de_l_extremite_de_l_axe_OY)           \
                                                                ,NIVEAU_DERIVEE_Y(niveau_de_VERTE_de_l_extremite_de_l_axe_OY)           \
                                                                ,NIVEAU_DERIVEE_Z(niveau_de_BLEUE_de_l_extremite_de_l_axe_OY)           \
                                                                ,rayon_de_l_extremite_des_axes_de_coordonnees                           \
                                                                ,NOMBRE_EFFECTIF_DE_POINTS_DES_AXES_DE_COORDONNEES                      \
                                                                ,DERNIERE_ITERATION_VISUALISEE                                          \
                                                                ,NE_PAS_INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES    \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                 );                                                                     \
                                        /* Visualisation de l'axe 'OY'.                                                              */ \
                         VISUALISATION_D_UNE_CHAINE_DE_CONNEXION(XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FXorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FYorigine                          \
                                                                                                    ,FZERO                              \
                                                                                                     )                                  \
                                                                ,XYZ_ORIGINE_DES_AXES_DE_COORDONNEES(FZorigine                          \
                                                                                                    ,longueur_des_axes_de_coordonnees   \
                                                                                                     )                                  \
                                                                ,NIVEAU_DERIVEE_X(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_ROUGE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_ROUGE_de_l_origine_de_l_axe_OZ         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Y(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_VERTE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_VERTE_de_l_origine_de_l_axe_OZ         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,NIVEAU_DERIVEE_Z(COND(EST_VRAI(la_couleur_origine_est_commune_a_XYZ)   \
                                                                                      ,niveau_de_BLEUE_de_l_origine_des_axes            \
                                                                                      ,niveau_de_BLEUE_de_l_origine_de_l_axe_OZ         \
                                                                                       )                                                \
                                                                                  )                                                     \
                                                                ,rayon_de_l_origine_des_axes_de_coordonnees                             \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FXorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FYorigine                        \
                                                                                                      ,FZERO                            \
                                                                                                       )                                \
                                                                ,XYZ_EXTREMITE_DES_AXES_DE_COORDONNEES(FZorigine                        \
                                                                                                      ,longueur_des_axes_de_coordonnees \
                                                                                                       )                                \
                                                                ,NIVEAU_DERIVEE_X(niveau_de_ROUGE_de_l_extremite_de_l_axe_OZ)           \
                                                                ,NIVEAU_DERIVEE_Y(niveau_de_VERTE_de_l_extremite_de_l_axe_OZ)           \
                                                                ,NIVEAU_DERIVEE_Z(niveau_de_BLEUE_de_l_extremite_de_l_axe_OZ)           \
                                                                ,rayon_de_l_extremite_des_axes_de_coordonnees                           \
                                                                ,NOMBRE_EFFECTIF_DE_POINTS_DES_AXES_DE_COORDONNEES                      \
                                                                ,DERNIERE_ITERATION_VISUALISEE                                          \
                                                                ,NE_PAS_INTERPOLER_LES_CHAINES_DE_CONNEXION_PAR_DES_SPLINES_CUBIQUES    \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                ,FLOT__UNDEF                                                            \
                                                                 );                                                                     \
                                        /* Visualisation de l'axe 'OZ'.                                                              */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation des trois axes de coordonnees.                                              */

BFonctionI

DEFV(Local,DEFV(FonctionI,visualisation_des_axes_de_coordonnees()))
                                        /* Cette fonction a ete introduite pour alleger les compilations (de 'v $xrk/fluide_2D.11$K' */
                                        /* en particulier...).                                                                       */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     INIT_ERROR;
     /*..............................................................................................................................*/
     gVISUALISATION_DES_AXES_DE_COORDONNEES;

     RETU_ERROR;
     Eblock

EFonctionI

#define   VISUALISATION_DES_AXES_DE_COORDONNEES                                                                                         \
                    Bblock                                                                                                              \
                    CALS(visualisation_des_axes_de_coordonnees());                                                                      \
                    Eblock                                                                                                              \
                                        /* Visualisation des trois axes de coordonnees.                                              */



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