/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N E T G E S T I O N D E L A L I S T E D E S P O I N T S : */
/* */
/* */
/* Author of '$xrv/champs_5.11$I' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1992??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D ' U N E L I S T E Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#include xrv/champs_5.41.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A L I S T E D E S P O I N T S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, jusqu'au 20010920094016, il y avait ici : */
/* */
/* #define DEFINITION_DES_LISTES_DE_POINTS_VERSION_01 */
/* #nodefine DEFINITION_DES_LISTES_DE_POINTS_VERSION_02 */
/* */
/* #ifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_01 */
/* # define PREMIER_POINT_DES_LISTES \ */
/* PREMIER_POINT */
/* #Aifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_01 */
/* #Eifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_01 */
/* */
/* #ifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_02 */
/* # define PREMIER_POINT_DES_LISTES \ */
/* PREMIER_ELEMENT_D_UN_FICHIER */
/* #Aifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_02 */
/* #Eifdef DEFINITION_DES_LISTES_DE_POINTS_VERSION_02 */
/* */
/* avec : */
/* */
/* PREMIER_POINT = PREMIERE_ITERATION_D_UN_Komp = 1 */
/* */
/* et : */
/* */
/* PREMIER_ELEMENT_D_UN_FICHIER = INDEX0 = 0 */
/* */
/* Or il est impossible de passer d'une VERSION a l'autre car, en effet, les "corps" qui */
/* utiliseront ces definitions seront geres par des 'Komp(...)' (on verra par exemple le */
/* programme 'v $xrk/rdn_walk.52K Komp' avec lequel j'ai reellement pris conscience de */
/* ce probleme). Il est donc essentiel qu'il y ait compatibilite entre la definition de */
/* 'PREMIER_POINT_DES_LISTES', les procedures d'acces aux listes que l'on va definir */
/* ensuite ('v $xrk/rdn_walk.52$K gACCES_IDENTITES') et la gestion des numeros des "corps" */
/* via les 'Komp(...)'... */
#define PREMIER_POINT_DES_LISTES \
PREMIER_POINT \
/* Definit l'index du premier point dans la liste... */
#if ( (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_ZONE_DE_SWAP_1)) \
&& (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_LIMIT_MEMORY_1)) \
)
# TestADef NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES \
CENT_MILLE \
/* Cette constante est destinee a dimensionner les listes "lineaires" de memorisation des */ \
/* points a visualiser... */
#Aif ( (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_ZONE_DE_SWAP_1)) \
&& (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_LIMIT_MEMORY_1)) \
)
# TestADef NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES \
DIX_MILLE \
/* Cette constante est destinee a dimensionner les listes "lineaires" de memorisation des */ \
/* points a visualiser... */
#Eif ( (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_ZONE_DE_SWAP_1)) \
&& (! defined(BUG_SYSTEME_NWS3000_NEWSOS_LACT23_EDFR11_HOME11_LIMIT_MEMORY_1)) \
)
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_points_visualisables,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES)));
/* Ceci fut introduit le 20111212160621 afin de pouvoir etre edite pour information via */
/* 'v $xrv/champs_5.1A$I nombre_maximal_de_points_visualisables'... */
/* */
/* Le 20200403094943, le type 'Int' est devenu 'Positive' plus logique... */
DEFV(Local,DEFV(Int,INIT(index_de_rangement_dans_la_liste,PREMIER_POINT_DES_LISTES)));
/* Index de rangement dans la liste... */
DEFV(Local,DEFV(Int,INIT(index_d_extraction_de_la_liste,PREMIER_POINT_DES_LISTES)));
/* Index d'extraction de la liste... */
gDEFINITION_LISTE(liste_des_index,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_numeros,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_X,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_Y,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_Z,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_GPOND,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_IDENTITE,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_MASSE,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_aRAYON,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_vRAYON,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_ROUGE,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_VERTE,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
gDEFINITION_LISTE(liste_des_BLEUE,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES);
/* Les points a visualiser sont memorises au prealable dans une liste "vectorielle" ; on */
/* ne fait pas appel a des vrais listes pour des raisons de performance. On trouve ainsi : */
/* */
/* index : index de permutation destine a trier la liste sans deplacer les elements, */
/* numero : memorise 'numero_de_l_iteration_courante', */
/* X : coordonnee 'X' dans [0,1], */
/* Y : coordonnee 'Y' dans [0,1], */
/* Z : coordonnee 'Z' dans [0,1] (c'est sur elle qu'a lieu le tri : elle donne la */
/* coordonnee 'Z' dans l'espace de visualisation, -infini etant derriere et */
/* et +infini devant), */
/* GPOND : contribution de cette sphere au calcul du pseudo-centre de gravite, */
/* IDENTITE : identite de la sphere de materialisation, */
/* MASSE : masse de la sphere de materialisation, */
/* aRAYON : rayon Absolu de la sphere de materialisation dans [0,1], */
/* vRAYON : rayon de Visualisation de la sphere de materialisation dans [0,1], */
/* ROUGE : composante ROUGE de la couleur dans [0,255], */
/* VERTE : composante VERTE de la couleur dans [0,255], */
/* BLEUE : composante BLEUE de la couleur dans [0,255]. */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N I T I A L I S A T I O N D E L A L I S T E D E S P O I N T S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, un dispositif de non reinitialisation des listes pour chaque image avait */
/* ete implemente le 1995062600. Il reposait en particulier sur la programmation suivante */
/* de 'INITIALISATION_DE_LA_LISTE_DES_POINTS' : */
/* */
/* #define REINITIALISER_LA_LISTE_DES_POINTS_AVANT_CHAQUE_IMAGE \ */
/* VRAI */
/* DEFV(Local,DEFV(Logical,INIT(reinitialiser_la_liste */
/* ,REINITIALISER_LA_LISTE */
/* ) */
/* ) */
/* ); */
/* DEFV(Local,DEFV(Logical,INIT(la_liste_des_points_a_ete_initialisee,FAUX))); */
/* */
/* #define INITIALISATION_DE_LA_LISTE_DES_POINTS \ */
/* Bblock \ */
/* Test(IFOU(IL_FAUT(reinitialiser_la_liste) \ */
/* ,IFET(IL_NE_FAUT_PAS(reinitialiser_la_liste) \ */
/* ,EST_FAUX(la_liste_des_points_a_ete_initialisee) \ */
/* ) \ */
/* ) \ */
/* ) \ */
/* Bblock \ */
/* EGAL(index_de_rangement_dans_la_liste \ */
/* ,PREMIER_POINT_DES_LISTES \ */
/* ); \ */
/* EGAL(la_liste_des_points_a_ete_initialisee,VRAI); \ */
/* Eblock \ */
/* ATes \ */
/* Bblock \ */
/* INCR(index_de_rangement_dans_la_liste,I); \ */
/* Eblock \ */
/* ETes \ */
/* Eblock \ */
/* */
/* Malheureusement, a cause de 'liste_des_index' cela ne peut pas fonctionner aussi */
/* simplement. En effet, au fur et a mesure, 'liste_des_index' finit par contenir */
/* n'importe quoi, et par exemple, plusieurs fois le meme index... */
/* */
/* Si besoin etait, il suffirait a l'entree de 'TRI_D_UNE_LISTE_DE_POINTS' de placer */
/* une boucle qui reinitialiserait systematiquement 'liste_des_index'. Mais comme ce */
/* dispositif est tres voisin des "trainees" (avec moins de possibilites, en particulier */
/* en ce qui concerne l'attenuation) il n'est pas utile de l'implementer... */
/* */
/* Enfin, cela est finalement peu interessant car, en effet, les points lorsqu'ils */
/* memorises ici ont deja subi les transformations geometriques. Ce qui aurait ete plus */
/* interessant c'est d'avoir dans les listes les points avant ces memes transformations. */
#ifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_01
# define INITIALISATION_DE_LA_LISTE_DES_POINTS \
Bblock \
EGAL(index_de_rangement_dans_la_liste,PREMIER_POINT_DES_LISTES); \
/* (re-)initialisation de l'index de rangement dans la liste... */ \
Eblock \
/* Initialisation de la liste des points avant chaque nouvelle image. */
#Aifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_01
#Eifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_01
#ifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_02
# define INITIALISATION_DE_LA_LISTE_DES_POINTS \
Bblock \
gINITIALISATION_LISTE(liste_des_index,FLOT__UNDEF,PREMIER_POINT_DES_LISTES,nombre_d_iterations); \
gINITIALISATION_LISTE(liste_des_numeros,FLOT__UNDEF,PREMIER_POINT_DES_LISTES,nombre_d_iterations); \
\
EGAL(index_de_rangement_dans_la_liste,PREMIER_POINT_DES_LISTES); \
/* (re-)initialisation de l'index de rangement dans la liste... */ \
Eblock \
/* Initialisation de la liste des points avant chaque nouvelle image. */
#Aifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_02
#Eifdef GESTION_DES_LISTES_QUELCONQUES_VERSION_02
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' U N E P S E U D O - I D E N T I T E : */
/* */
/*************************************************************************************************************************************/
#define DEFINITION_DE_L_IDENTITE_DE_LA_SPHERE_COURANTE(identite) \
Bblock \
EGAL(identite_de_la_sphere_courante,identite); \
Eblock
#define IDENTITE_PAR_DEFAUT_D_UNE_SPHERE \
ZERO
DEFV(Local,DEFV(Int,INIT(identite_de_la_sphere_courante,IDENTITE_PAR_DEFAUT_D_UNE_SPHERE)));
/* Identite de de la sphere courante de visualisation. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E D I T I O N D ' U N P S E U D O - C E N T R E D E G R A V I T E */
/* S E S C O O R D O N N E E S E T A N T E X P R I M E E S D A N S [0,1+h]x[0,1]x[0,1] */
/* ( O U ' h ' E S T L A P O U R P R E N D R E E N C O M P T E L E F O R M A T : */
/* */
/*************************************************************************************************************************************/
#define EDITER_LE_PSEUDO_CENTRE_DE_GRAVITE \
FAUX
DEFV(Local,DEFV(Logical,INIT(editer_le_pseudo_centre_de_gravite,EDITER_LE_PSEUDO_CENTRE_DE_GRAVITE)));
/* Cet indicateur permet d'editer un pseudo-centre de gravite. On notera que l'on parle */
/* de pseudo-centre de gravite (introduit le 19980205124220) car, en effet, il n'y a pas */
/* a priori de notion de masse. Celle-ci existe dans les programmes 'v $xrr/N_corps.11$K' */
/* ou 'v $xrk/rdn_walk.41$K', par exemple, mais n'est pas generale. D'ou ici, cette notion */
/* de masse obtenue par une combinaison lineaire des elements : */
/* */
/* 3 */
/* {MASSE,RAYON ,ROUGE,VERTE,BLEUE} */
/* */
/* pour chaque point. Malgre tout, on voit que l'on utilise le cube du rayon qui est donc */
/* proportionnel au volume des spheres et donc a leur masse (on ignore quand meme ici la */
/* masse volumique...). Le 19980209085052, j'ai commence malgre tout a introduire une vraie */
/* masse... */
#define DEFINITION_PONDERATION_DU_PSEUDO_CENTRE_DE_GRAVITE_DE_LA_SPHERE_COURANTE(ponderation) \
Bblock \
EGAL(ponderation_du_pseudo_centre_de_gravite_de_la_sphere_courante,ponderation); \
Eblock
#define PONDERATION_DU_PSEUDO_CENTRE_DE_GRAVITE_DE_LA_SPHERE_COURANTE \
FU
DEFV(Local,DEFV(Float,INIT(ponderation_du_pseudo_centre_de_gravite_de_la_sphere_courante
,PONDERATION_DU_PSEUDO_CENTRE_DE_GRAVITE_DE_LA_SPHERE_COURANTE
)
)
);
/* Ponderation de la sphere courante pour le calcul du pseudo-centre de gravite. Ainsi, */
/* lorsque 'DEFINITION_PONDERATION_DU_PSEUDO_CENTRE_DE_GRAVITE_DE_LA_SPHERE_COURANTE(...)' */
/* n'est pas utilisee, toutes les spheres ont la meme ponderation lors du calcul du */
/* pseudo-centre de gravite 'PONDERATION_DU_PSEUDO_CENTRE_DE_GRAVITE_DE_LA_SPHERE_COURANTE'. */
/* Ce dispositif a ete introduit le 19990608091843, principalement pour etre utilise dans */
/* 'v $xrr/N_corps.11$K ACCES_PONDERATION_CENTRE_DE_GRAVITE'. */
#define DEFINITION_DE_LA_MASSE_DE_LA_SPHERE_COURANTE(masse) \
Bblock \
EGAL(masse_de_la_sphere_courante,masse); \
Eblock
#define MASSE_PAR_DEFAUT_D_UNE_SPHERE \
FU
DEFV(Local,DEFV(Float,INIT(masse_de_la_sphere_courante,MASSE_PAR_DEFAUT_D_UNE_SPHERE)));
/* Masse de la sphere courante de visualisation et son positionnement. On voit ainsi que */
/* pour les programmes n'utilisant pas 'DEFINITION_DE_LA_MASSE_DE_LA_SPHERE_COURANTE(...)' */
/* chaque sphere a la meme masse 'MASSE_PAR_DEFAUT_D_UNE_SPHERE'. */
#define FACTEUR_NEUTRE_DU_PSEUDO_CENTRE_DE_GRAVITE \
FZERO
#define FACTEUR_MASSE_DU_PSEUDO_CENTRE_DE_GRAVITE \
FU
#define FACTEUR_RAYON_DU_PSEUDO_CENTRE_DE_GRAVITE \
FZERO
#define FACTEUR_ROUGE_DU_PSEUDO_CENTRE_DE_GRAVITE \
FZERO
#define FACTEUR_VERTE_DU_PSEUDO_CENTRE_DE_GRAVITE \
FZERO
#define FACTEUR_BLEUE_DU_PSEUDO_CENTRE_DE_GRAVITE \
FZERO
DEFV(Local,DEFV(Float,INIT(facteur_NEUTRE_du_pseudo_centre_de_gravite,FACTEUR_NEUTRE_DU_PSEUDO_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Float,INIT(facteur_MASSE_du_pseudo_centre_de_gravite,FACTEUR_MASSE_DU_PSEUDO_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Float,INIT(facteur_RAYON_du_pseudo_centre_de_gravite,FACTEUR_RAYON_DU_PSEUDO_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Float,INIT(facteur_ROUGE_du_pseudo_centre_de_gravite,FACTEUR_ROUGE_DU_PSEUDO_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Float,INIT(facteur_VERTE_du_pseudo_centre_de_gravite,FACTEUR_VERTE_DU_PSEUDO_CENTRE_DE_GRAVITE)));
DEFV(Local,DEFV(Float,INIT(facteur_BLEUE_du_pseudo_centre_de_gravite,FACTEUR_BLEUE_DU_PSEUDO_CENTRE_DE_GRAVITE)));
/* Facteurs de la ponderation des coordonnees donnant le pseudo-centre de gravite. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E D I T I O N D E L A L I S T E D E S P O I N T S D A N S L ' E S P A C E */
/* T R I D I M E N S I O N E L ( N O N P R O J E T E ) : */
/* */
/*************************************************************************************************************************************/
#define EDITER_LE_NOMBRE_DE_POINTS_MEMORISES \
FAUX
DEFV(Local,DEFV(Logical,INIT(editer_le_nombre_de_points_memorises,EDITER_LE_NOMBRE_DE_POINTS_MEMORISES)));
/* Cet indicateur permet d'editer le nombre de points memorises. Il a ete introduit le */
/* 20200402115605 a des fins de test... */
#define LISTER_LA_LISTE_DES_POINTS \
FAUX
DEFV(Local,DEFV(Logical,INIT(lister_la_liste_des_points,LISTER_LA_LISTE_DES_POINTS)));
/* Cet indicateur permet d'editer la liste des points. Ceci a ete ajoute le 19970617172613 */
/* apres l'introduction des programmes du type '$xrv/map_ND_2D.11$K'. */
/* */
/* ATTENTION, etant donnee la definition des fonctions 'X_PHYSIQUE_DANS_01(...)', */
/* 'Y_PHYSIQUE_DANS_01(...)' et 'Z_PHYSIQUE_DANS_01(...)', ainsi que celles des variables */
/* 'TRANSLATION_DE_X_PHYSIQUE', 'TRANSLATION_DE_Y_PHYSIQUE' et 'TRANSLATION_DE_Z_PHYSIQUE' */
/* qu'elles utilisent, les valeurs obtenues sont a priori et par defaut dans : */
/* */
/* x E [0,1] */
/* y E [0,1] */
/* z E [-1/2,+1/2] */
/* */
/* ce qui peut demander une translation a l'edition en particulier pour le 'z' par : */
/* */
/* TZliste=0.5 */
/* */
/* afin de le ramener dans : */
/* */
/* z E [0,1] */
/* */
/* ce qui est essentiel si l'on veut ensuite utiliser '$xrv/particule.10$K' en particulier */
/* avec des transformations de type rotation... */
#define LISTER_LA_LISTE_DES_POINTS_APRES_TOUTES_LES_TRANSFORMATIONS \
VRAI
DEFV(Local,DEFV(Logical,INIT(lister_la_liste_des_points_apres_toutes_les_transformations
,LISTER_LA_LISTE_DES_POINTS_APRES_TOUTES_LES_TRANSFORMATIONS
)
)
);
/* Cet indicateur indique, a condition que 'IL_FAUT(lister_la_liste_des_points)', si cette */
/* edition a lieu apres toutes les transformations ('TRANSFORMATION_GEOMETRIQUE_3D_Fx?(...)' */
/* et la mise dans [0,1] en particulier) ou alors avant toute autre chose. Ceci a ete ajoute */
/* le 19980416122932 a cause de difficultes pour faire des rotations sur des objets generes */
/* comme 'v $xiirv/REGL.14'. */
#define LISTER_LE_TEMPS_LORS_DE_LISTER_LA_LISTE_DES_POINTS \
FAUX
DEFV(Local,DEFV(Logical,INIT(lister_le_temps_lors_de_lister_la_liste_des_points
,LISTER_LE_TEMPS_LORS_DE_LISTER_LA_LISTE_DES_POINTS
)
)
);
/* Cet indicateur indique, a condition que 'IL_FAUT(lister_la_liste_des_points)', si il */
/* faut editer le temps courant en plus de la periode courante. */
#define QUANTIFIER_LE_TEMPS_LORS_DE_LISTER_LA_LISTE_DES_POINTS \
VRAI
DEFV(Local,DEFV(Logical,INIT(quantifier_le_temps_lors_de_lister_la_liste_des_points
,QUANTIFIER_LE_TEMPS_LORS_DE_LISTER_LA_LISTE_DES_POINTS
)
)
);
#define FACTEUR_DE_QUANTIFICATION_DU_TEMPS \
FU
DEFV(Local,DEFV(Float,INIT(facteur_de_quantification_du_temps
,FACTEUR_DE_QUANTIFICATION_DU_TEMPS
)
)
);
/* A condition que 'IL_FAUT(lister_le_temps_lors_de_lister_la_liste_des_points)', cet */
/* indicateur s'il faut quantifier ou pas le temps, et le facteur a utiliser. */
DEFV(pointF_3D,INIS(position_du_touriste_observateur_relativiste
,IstructL03(Xcentre_ESPACE,Ycentre_ESPACE,Zcentre_ESPACE)
)
);
#define X_de_l_observateur_relativiste \
ASD1(position_du_touriste_observateur_relativiste,x)
#define Y_de_l_observateur_relativiste \
ASD1(position_du_touriste_observateur_relativiste,y)
#define Z_de_l_observateur_relativiste \
ASD1(position_du_touriste_observateur_relativiste,z)
/* Position de l'observateur relativiste. Il pourra etre utile de donner a ce point la meme */
/* position que le point 'v $xiii/vecteurs$FON position_de_l_observateur', mais cela n'est */
/* pas obligatoire... */
/* */
/* Le 20061113122045, 'position_de_l_observateur_relativiste' fut remplace par */
/* 'position_du_touriste_observateur_relativiste' pour prepaper l'execution de */
/* 'v $xau/LACT16.61.modifier$sed position_de_l_observateur' via 'v $xau/LACT16.82$Z' */
/* et eviter ainsi une grosse ambiguite... */
/* ambiguite... */
#define PROPAGATION_INSTANTANEE_DES_INFORMATIONS \
FZERO
DEFV(Local,DEFV(Float,INIT(vitesse_de_propagation_des_informations,PROPAGATION_INSTANTANEE_DES_INFORMATIONS)));
/* Vitesse de propagation des informations ; la valeur implicite implique une propagation */
/* instanee, mais on pourra utiliser, par exemple, 'VITESSE_DE_LA_LUMIERE'. On notera que */
/* la valeur de 'PROPAGATION_INSTANTANEE_DES_INFORMATIONS' est egale a 'FZERO' alors qu'il */
/* aurait ete plus logique de lui donner la valeur 'F_INFINI'. Ceci est en destine a */
/* simplifier l'utilisation de l'option "celerite=" (c'est plus facile d'entrer '0'...). */
#define ECHELLE_OX_POUR_LISTER_LA_LISTE_DES_POINTS \
FU
#define ECHELLE_OY_POUR_LISTER_LA_LISTE_DES_POINTS \
FU
#define ECHELLE_OZ_POUR_LISTER_LA_LISTE_DES_POINTS \
FU
DEFV(Local,DEFV(Float,INIT(echelle_OX_pour_lister_la_liste_des_points,ECHELLE_OX_POUR_LISTER_LA_LISTE_DES_POINTS)));
DEFV(Local,DEFV(Float,INIT(echelle_OY_pour_lister_la_liste_des_points,ECHELLE_OY_POUR_LISTER_LA_LISTE_DES_POINTS)));
DEFV(Local,DEFV(Float,INIT(echelle_OZ_pour_lister_la_liste_des_points,ECHELLE_OZ_POUR_LISTER_LA_LISTE_DES_POINTS)));
/* Lorsque la liste des points est editee, on peut translater les coordonnees. */
#define TRANSLATION_OX_POUR_LISTER_LA_LISTE_DES_POINTS \
FZERO
#define TRANSLATION_OY_POUR_LISTER_LA_LISTE_DES_POINTS \
FZERO
#define TRANSLATION_OZ_POUR_LISTER_LA_LISTE_DES_POINTS \
FZERO
DEFV(Local,DEFV(Float,INIT(translation_OX_pour_lister_la_liste_des_points,TRANSLATION_OX_POUR_LISTER_LA_LISTE_DES_POINTS)));
DEFV(Local,DEFV(Float,INIT(translation_OY_pour_lister_la_liste_des_points,TRANSLATION_OY_POUR_LISTER_LA_LISTE_DES_POINTS)));
DEFV(Local,DEFV(Float,INIT(translation_OZ_pour_lister_la_liste_des_points,TRANSLATION_OZ_POUR_LISTER_LA_LISTE_DES_POINTS)));
/* Lorsque la liste des points est editee, on peut translater les coordonnees. */
#define X_COORDONNEE_DU_POINT_COURANT(x,y,z) \
AXPB(echelle_OX_pour_lister_la_liste_des_points \
,x \
,translation_OX_pour_lister_la_liste_des_points \
)
#define Y_COORDONNEE_DU_POINT_COURANT(x,y,z) \
AXPB(echelle_OY_pour_lister_la_liste_des_points \
,y \
,translation_OY_pour_lister_la_liste_des_points \
)
#define Z_COORDONNEE_DU_POINT_COURANT(x,y,z) \
AXPB(echelle_OZ_pour_lister_la_liste_des_points \
,z \
,translation_OZ_pour_lister_la_liste_des_points \
)
/* Acces aux coordonnees {x,y,z} du point courant. */
#ifndef DCT_EFFECTIF
# define DCT_EFFECTIF \
dct \
/* Pour des raisons de compatibilite avec 'v $xrk/rdn_walk.52$K DCT_EFFECTIF'. */
#Aifndef DCT_EFFECTIF
#Eifndef DCT_EFFECTIF
#define LISTER_LA_PERIODE_DE_LA_LISTE_DES_POINTS(x,y,z) \
Bblock \
CAL2(Prin1("periode=%d" \
,numero_de_la_periode_courante \
) \
); \
\
Test(IL_FAUT(lister_le_temps_lors_de_lister_la_liste_des_points)) \
Bblock \
DEFV(Float,INIT(retard_relativiste \
,COND(IFEQ(vitesse_de_propagation_des_informations,PROPAGATION_INSTANTANEE_DES_INFORMATIONS) \
,FZERO \
,fDIVZ(RdisF3D(COND(IL_FAUT(lister_la_liste_des_points_apres_toutes_les_transformations) \
,X_PHYSIQUE_DANS_01(X_de_l_observateur_relativiste) \
,X_de_l_observateur_relativiste \
) \
,COND(IL_FAUT(lister_la_liste_des_points_apres_toutes_les_transformations) \
,Y_PHYSIQUE_DANS_01(Y_de_l_observateur_relativiste) \
,Y_de_l_observateur_relativiste \
) \
,COND(IL_FAUT(lister_la_liste_des_points_apres_toutes_les_transformations) \
,Z_PHYSIQUE_DANS_01(Z_de_l_observateur_relativiste) \
,Z_de_l_observateur_relativiste \
) \
,X_COORDONNEE_DU_POINT_COURANT(x,y,z) \
,Y_COORDONNEE_DU_POINT_COURANT(x,y,z) \
,Z_COORDONNEE_DU_POINT_COURANT(x,y,z) \
) \
,vitesse_de_propagation_des_informations \
) \
) \
) \
); \
/* Calcul d'un eventuel retard "relativiste". L'utilisation de '?_PHYSIQUE_DANS_01(...)' */ \
/* a ete introduit le 19990527091055, c'est-a-dire apres la generation des sequences : */ \
/* */ \
/* xivPdf 6 1 / 003937_004064 */ \
/* xivPdf 6 1 / 004065_004192 */ \
/* */ \
\
Test(IL_FAUT(quantifier_le_temps_lors_de_lister_la_liste_des_points)) \
Bblock \
EGAL(retard_relativiste \
,fARRI(retard_relativiste \
,MUL2(facteur_de_quantification_du_temps,DCT_EFFECTIF) \
) \
); \
/* Quantification eventuelle du temps... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CAL2(Prin1(" t=%+.^^^",ADD2(temps_courant,retard_relativiste))); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition de la periode courante et eventuellement du temps (ajoute le 19990510135228) */ \
/* en prevision d'une visualisation de type "relativite restreinte", ou les points ne */ \
/* seraient plus visualises a l'instant 't', mais a l'intant 't+Dt', le retard 'Dt' etant */ \
/* egal au quotient de la distance de ce point a un certain observateur par une certaine */ \
/* celerite... */
#define LISTER_LA_LISTE_DES_COORDONNEES_DES_POINTS(x,y,z) \
Bblock \
CAL2(Prin3(" X=%+.^^^ Y=%+.^^^ Z=%+.^^^" \
,X_COORDONNEE_DU_POINT_COURANT(x,y,z) \
,Y_COORDONNEE_DU_POINT_COURANT(x,y,z) \
,Z_COORDONNEE_DU_POINT_COURANT(x,y,z) \
) \
); \
/* ATTENTION, les coordonnees {X,Y,Z} sont dans l'espace tridimensionnel, c'est-a-dire */ \
/* qu'elles ne sont pas projetees dans le plan de l'image... */ \
/* */ \
/* Suite au probleme 'v $xiirs/$Fnota 20040330115702', le 20040410152458, le format "%+.16g" */ \
/* a ete remplace par "%+.18g" afin de montrer d'infimes differences... */ \
/* */ \
/* Le 20060105160451, le format "18g" est conserve a cause de la modification decrite */ \
/* ci-dessus. Finalement, le 20060109092901 le format "18g" est devenu "^^g" suite a la */ \
/* modification 'v $xig/fonct$vv$FON 20060105164504' qui demande par defaut 18 chiffres... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
/* Edition des coordonnees {x,y,z} du point courant. */
DEFV(Local,DEFV(Logical,INIT(la_vitesse_de_la_sphere_courante_a_ete_utilisee_au_moins_une_fois,FAUX)));
/* Afin de savoir si l'edition dans 'LISTER_LA_LISTE_DES_VITESSES_DES_POINTS(...)' est */
/* utile... */
#define VITESSE_PAR_DEFAUT_D_UNE_SPHERE \
FZERO
DEFV(deltaF_3D,INIS(vitesse_de_la_sphere_courante
,IstructL03(VITESSE_PAR_DEFAUT_D_UNE_SPHERE,VITESSE_PAR_DEFAUT_D_UNE_SPHERE,VITESSE_PAR_DEFAUT_D_UNE_SPHERE)
)
);
#define VX_de_la_sphere_courante \
ASD1(vitesse_de_la_sphere_courante,dx)
#define VY_de_la_sphere_courante \
ASD1(vitesse_de_la_sphere_courante,dy)
#define VZ_de_la_sphere_courante \
ASD1(vitesse_de_la_sphere_courante,dz)
/* Vitesse de la sphere courante de visualisation. On voit ainsi que pour les programmes */
/* n'utilisant pas 'DEFINITION_DE_LA_VITESSE_DE_LA_SPHERE_COURANTE(...)' chaque sphere a */
/* meme vitesse {VITESSE_PAR_DEFAUT_D_UNE_SPHERE,VITESSE_PAR_DEFAUT_D_UNE_SPHERE,...}'. */
#define DEFINITION_DE_LA_VITESSE_DE_LA_SPHERE_COURANTE(vx,vy,vz) \
Bblock \
INITIALISATION_ACCROISSEMENT_3D(vitesse_de_la_sphere_courante,vx,vy,vz); \
\
EGAL(la_vitesse_de_la_sphere_courante_a_ete_utilisee_au_moins_une_fois,VRAI); \
Eblock
#define LISTER_LA_LISTE_DES_VITESSES_DES_POINTS \
Bblock \
Test(EST_VRAI(la_vitesse_de_la_sphere_courante_a_ete_utilisee_au_moins_une_fois)) \
Bblock \
CAL2(Prin3(" VX=%+.^^^ VY=%+.^^^ VZ=%+.^^^" \
,VX_de_la_sphere_courante,VY_de_la_sphere_courante,VZ_de_la_sphere_courante \
) \
); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
CAL2(Prin1(" VITESSE=%+.^^^" \
,longF3D(vitesse_de_la_sphere_courante) \
) \
); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition des vitesses {vx,vy,vz} du point courant. Cela a ete ajoute le 19980630135924 */ \
/* afin de permettre a des programmes tels 'v $xrk/rdn_walk.41$K' de pouvoir editer l'etat */ \
/* final d'une simulation afin que celui-ci puisse servir de conditions initiales a une */ \
/* autre simulation, par exemple, en ayant modifie la geometrie du milieu. ATTENTION, lors */ \
/* d'une telle utilisation l'etat final d'une simulation 'N' est alors strictement identique */ \
/* a l'etat initial de la suivante 'N+1' (heureusement...) ce qui signifie que la derniere */ \
/* image de la simulation 'N' et la premiere image de la simulation 'N+1' sont identiques et */ \
/* donc, cette premiere image doit etre ignoree ('v _____xivPdf_11_2/$Fnota 017921_018432'). */
#define LISTER_LA_LISTE_DES_ENERGIES_CINETIQUES_DES_POINTS \
Bblock \
Test(EST_VRAI(la_vitesse_de_la_sphere_courante_a_ete_utilisee_au_moins_une_fois)) \
Bblock \
CAL2(Prin1(" ENERGIE_CINETIQUE=%+.^^^" \
,MOIT(MUL2(masse_de_la_sphere_courante \
,pytF3D(vitesse_de_la_sphere_courante) \
) \
) \
) \
); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition de l'energie cinetique du point courant. Cela a ete ajoute le 19980708175109 */ \
/* car cela peut etre utile dans des simulations de type thermodynamique puisque la */ \
/* temperature est proportionnelle a l'energie cinetique moyenne des particules a un */ \
/* instant donne. */
#define LISTER_LA_LISTE_DES_RAYONS_DES_POINTS(rayon) \
Bblock \
CAL2(Prin1(" RAYON=%.^^^" \
,rayon \
) \
); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
/* Edition du rayon du point courant. */ \
/* */ \
/* On notera le 20110712103021 que le resultat de cette edition depend fortement du fait */ \
/* qu'elle a lieu AVANT les transformation (auquel cas on trouve bien 'champ_RAYON', */ \
/* c'est-a-dire les rayons tels qu'ils ont ete specifies en tant qu'arguments des '$X'), */ \
/* alors qu'APRES ils subissent une transformation (c'est 'rayon_reel_absolu')... */
#define LISTER_LA_LISTE_DES_COULEURS_DES_POINTS(rouge,verte,bleue) \
Bblock \
CAL2(Prin3(" ROUGE=%+.^^^ VERTE=%+.^^^ BLEUE=%+.^^^" \
,F___DENORMALISE_NIVEAU(rouge),F___DENORMALISE_NIVEAU(verte),F___DENORMALISE_NIVEAU(bleue) \
) \
); \
/* On notera le '__DENORMALISE_NIVEAU(...)' destine a la compatibilite avec les arguments */ \
/* de '$xrv/particule.10$K' (voir '"LISTE_ROUGE="' par exemple...). On notera de plus que */ \
/* le 19990526102122 a ete ajoute un espace derriere la valeur de "BLEUE=" afin de */ \
/* symetriser la recuperation des composantes chromatiques {ROUGE,VERTE,BLEUE}... */ \
/* */ \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
/* Edition des couleurs {rouge,verte,bleue} du point courant. */
#define OUVRIR_L_ENTREE_COURANTE_DE_LA_LISTE \
Bblock \
BLOC(VIDE;); \
Eblock
#define FERMER_L_ENTREE_COURANTE_DE_LA_LISTE \
Bblock \
CAL2(Prin0(" \n")); \
Eblock
/* Introduits le 20210104115459... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A L A L I S T E D E S P O I N T S E T E D I T I O N E V E N T U E L L E */
/* D A N S L ' E S P A C E T R I D I M E N S I O N E L ( N O N P R O J E T E ) : */
/* */
/*************************************************************************************************************************************/
#TestADef GENERATION_DE__liste_des_Z_____COMPATIBILITE_2008030913 \
FAUX
DEFV(Local,DEFV(Logical,INIT(generation_de__liste_des_Z_____compatibilite_2008030913
,GENERATION_DE__liste_des_Z_____COMPATIBILITE_2008030913
)
)
);
/* Afin d'assurer la compatibilite avec les resultats obtenus anterieurement a la date */
/* du 20080309112355... */
#TestADef GENERATION_DE__liste_des_Z_____COMPATIBILITE_20110711 \
FAUX
DEFV(Local,DEFV(Logical,INIT(generation_de__liste_des_Z_____compatibilite_20110711
,GENERATION_DE__liste_des_Z_____COMPATIBILITE_20110711
)
)
);
/* Afin d'assurer la compatibilite avec les resultats obtenus anterieurement a la date */
/* du 20110711174331... */
#define ACCES_LISTE(liste,index) \
gACCES_LISTE(index,liste,PREMIER_POINT_DES_LISTES,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES) \
/* Fonction d'acces a une liste quelconque. */ \
/* */ \
/* ATTENTION a ne pas confondre : */ \
/* */ \
/* 1-'ACCES_LISTE(...)', pour lequel le premier element vaut : */ \
/* */ \
/* PREMIER_POINT_DES_LISTES=PREMIER_POINT=PREMIERE_ITERATION_D_UN_Komp=UN */ \
/* */ \
/* qui est donc adapte a une gestion de type 'Komp(...)' ou le premier element est defini */ \
/* implicitement (et vaut donc 'UN'), et */ \
/* */ \
/* 2-'gELEMENT_DU_FICHIER(...)', pour lequel le premier element vaut : */ \
/* */ \
/* PREMIER_ELEMENT_D_UN_FICHIER=INDEX0=ZERO */ \
/* */ \
/* qui ne peut utiliser 'Komp(...)' et demande donc une gestion de type 'DoIn(...)' en */ \
/* precisant le premier element en tant qu'argument du 'DoIn(...)' (et valant donc 'ZERO'). */
DEFV(Local,DEFV(Float,INIT(minimum_de_la_coordonnee_X,F_INFINI)));
DEFV(Local,DEFV(Float,INIT(maximum_de_la_coordonnee_X,F_MOINS_L_INFINI)));
DEFV(Local,DEFV(Float,INIT(minimum_de_la_coordonnee_Y,F_INFINI)));
DEFV(Local,DEFV(Float,INIT(maximum_de_la_coordonnee_Y,F_MOINS_L_INFINI)));
DEFV(Local,DEFV(Float,INIT(minimum_de_la_coordonnee_Z,F_INFINI)));
DEFV(Local,DEFV(Float,INIT(maximum_de_la_coordonnee_Z,F_MOINS_L_INFINI)));
/* Calcul des extrema de {X,Y,Z} introduit le 20050419141059... */
DEFV(Local,DEFV(Positive,INIT(nombre_de_points_listes_apres_toutes_transformations,ZERO)));
/* Compteur introduit le 20131214183150 ('v $xrv/champs_5.26$I 20131214183150') et */
/* deplace ici le 20140823131219 a cause des '$K's de '$xrq'... */
#define MEMORISATION_D_UN_POINT(x,y,z,Arayon,Vrayon,rouge,verte,bleue) \
Bblock \
Test(IFLE(index_de_rangement_dans_la_liste \
,LSTX(PREMIER_POINT_DES_LISTES,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES) \
) \
) \
/* Le 20070727153348, le 'IFLT(...)' est remplace par un 'IFLE(...)' beaucoup plus */ \
/* logique (meme si l'ecriture anterieure donnait une petite marge de securite -1-)... */ \
Bblock \
Test(IFET(IFET(IZGT(Arayon),IZGT(Vrayon)) \
,IFOU(EST_VRAI(les_trois_les_differentielles_peuvent_etre_nulles) \
,IFET(EST_FAUX(les_trois_les_differentielles_peuvent_etre_nulles) \
,IFOU(IL_NE_FAUT_PAS(renormaliser_arbitrairement_les_differentielles) \
,IFET(IL_FAUT(renormaliser_arbitrairement_les_differentielles) \
,I3OU(IZNE(rouge),IZNE(verte),IZNE(bleue)) \
) \
) \
) \
) \
) \
) \
/* Le test oublie sur 'renormaliser_arbitrairement_les_differentielles' a ete ajoute */ \
/* le 19980304153153. */ \
/* */ \
/* Le 20030129175316, j'ai remplace le test : */ \
/* */ \
/* I3OU(IZGT(champ_ROUGE),IZGT(champ_VERTE),IZGT(champ_BLEUE)) */ \
/* */ \
/* qui testait la "positivite stricte" par un test sur la "non nullite stricte" qui */ \
/* semble plus logique, sans que je puisse reellement le justifier. Peut-etre s'agit-il */ \
/* d'un archaisme qui suppose que la nullite est associee a l'invisibilite. Il conviendrait */ \
/* */ \
/* Le 20030130132442, l'indicateur 'les_trois_les_differentielles_peuvent_etre_nulles' a */ \
/* ete introduit afin de supprimer l'archaisme mis en evidence le 20030129175316, tout en */ \
/* permettant une compatibilite par rapport aux executions anterieures... */ \
Bblock \
/* Cas ou le point {Xf,Yf,Zf} a un rayon strictement positif et ou au moins l'une des */ \
/* trois composantes est strictement positive : */ \
EGAL(minimum_de_la_coordonnee_X,MIN2(minimum_de_la_coordonnee_X,x)); \
EGAL(maximum_de_la_coordonnee_X,MAX2(maximum_de_la_coordonnee_X,x)); \
EGAL(minimum_de_la_coordonnee_Y,MIN2(minimum_de_la_coordonnee_Y,y)); \
EGAL(maximum_de_la_coordonnee_Y,MAX2(maximum_de_la_coordonnee_Y,y)); \
EGAL(minimum_de_la_coordonnee_Z,MIN2(minimum_de_la_coordonnee_Z,z)); \
EGAL(maximum_de_la_coordonnee_Z,MAX2(maximum_de_la_coordonnee_Z,z)); \
/* Calcul des extrema de {X,Y,Z} introduit le 20050419141059... */ \
\
EGAL(ACCES_LISTE(liste_des_index,index_de_rangement_dans_la_liste) \
,FLOT(index_de_rangement_dans_la_liste) \
); \
EGAL(ACCES_LISTE(liste_des_numeros,index_de_rangement_dans_la_liste) \
,FLOT(numero_de_l_iteration_courante) \
); \
EGAL(ACCES_LISTE(liste_des_X,index_de_rangement_dans_la_liste),x); \
EGAL(ACCES_LISTE(liste_des_Y,index_de_rangement_dans_la_liste),y); \
EGAL(ACCES_LISTE(liste_des_Z,index_de_rangement_dans_la_liste) \
,COND(IL_FAUT(generation_de__liste_des_Z_____compatibilite_2008030913) \
,NEUT(z) \
,ADD2(z \
,COND(IL_FAUT(generation_de__liste_des_Z_____compatibilite_20110711) \
,Arayon \
,MUL2(mgEPSILON,Arayon) \
) \
) \
) \
); \
EGAL(ACCES_LISTE(liste_des_GPOND,index_de_rangement_dans_la_liste) \
,ponderation_du_pseudo_centre_de_gravite_de_la_sphere_courante \
); \
EGAL(ACCES_LISTE(liste_des_IDENTITE,index_de_rangement_dans_la_liste) \
,FLOT(identite_de_la_sphere_courante) \
); \
EGAL(ACCES_LISTE(liste_des_MASSE,index_de_rangement_dans_la_liste),masse_de_la_sphere_courante); \
EGAL(ACCES_LISTE(liste_des_aRAYON,index_de_rangement_dans_la_liste),Arayon); \
EGAL(ACCES_LISTE(liste_des_vRAYON,index_de_rangement_dans_la_liste),Vrayon); \
EGAL(ACCES_LISTE(liste_des_ROUGE,index_de_rangement_dans_la_liste),rouge); \
EGAL(ACCES_LISTE(liste_des_VERTE,index_de_rangement_dans_la_liste),verte); \
EGAL(ACCES_LISTE(liste_des_BLEUE,index_de_rangement_dans_la_liste),bleue); \
/* Rangement du point {x,y,z,Arayon,Vrayon,rouge,verte,bleue) en queue de liste. On notera */ \
/* que l'index de rangement est aussi memorise : cela est destine au tri sur la coordonnee */ \
/* 'Z'. */ \
/* */ \
/* Le 20080309133637, c'est non plus 'z' qui est mis dans le Z-Buffer, mais 'z+Arayon' afin */ \
/* que si deux spheres sont concentriques, la plus grosse est consideree au premier plan... */ \
/* Avant cette date, utiliser donc 'z' introduisait des points aberrants lors du traitement */ \
/* de l'anti-aliasing... */ \
/* */ \
/* Le 20110711172700, je note que la modification du 20080309133637 consistant a memoriser */ \
/* 'z+Arayon' a la place de 'z' ne fonctionne que si les coordonnees {x,y,z} ne sont pas */ \
/* ensuite l'objet d'une rotation. Dans le cas contraire, en supposant, par exemple, une */ \
/* rotation de '$pis4' par rapport a 'OY', la sphere "exterieure" apparaitra decalee vers */ \
/* la droite. Cela s'est vu a cette date avec 'v $xiirs/PROK.41' dans laquelle les barres */ \
/* de jonction materialisant le reseau cubique intersectent de facon incorrecte les grosses */ \
/* boules materialisant les noeuds du reseau... */ \
/* */ \
/* Le 20110711174331, il fut donc decide d'utiliser, par defaut, la coordonnee 'z' */ \
/* translatee d'une petite fraction de 'Arayon' (afin de resoudre les problemes du */ \
/* traitement de l'anti-aliasing evoques le 20080309133637...). */ \
\
Test(IFET(IL_FAUT(lister_la_liste_des_points) \
,EST_VRAI(lister_la_liste_des_points_apres_toutes_les_transformations) \
) \
) \
Bblock \
/* Jusqu'au 20060413125024, il y avait ici : */ \
/* */ \
/* Test(IFEQ(index_de_rangement_dans_la_liste,PREMIER_POINT_DES_LISTES)) */ \
/* Bblock */ \
/* CAL2(Prin0("\n")); */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* mais a caude de 'v $xrs/surfaces.12$I lister_les_coordonnees_u_et_v_des_points', il ne */ \
/* faut plus emettre ce "\n" initial (dont je ne vois d'ailleurs plus l'interet...) car, */ \
/* en effet, il a pour effet de couper la premiere ligne en deux lorsque l'edition des */ \
/* coordonnees {u,v} des surfacest est demande. On notera au passage, que le 'Test(...)' */ \
/* supprime ne pouvait tester 'lister_les_coordonnees_u_et_v_des_points' car cette variable */ \
/* n'existe que pour les '$K' appartenant a '$xrs'... */ \
\
INCR(nombre_de_points_listes_apres_toutes_transformations,I); \
/* Comptage introduit le 20131214183539... */ \
\
OUVRIR_L_ENTREE_COURANTE_DE_LA_LISTE; \
/* Introduit le 20210104115459... */ \
\
LISTER_LA_PERIODE_DE_LA_LISTE_DES_POINTS(x,y,z); \
\
CAL2(Prin1(" point=%d" \
,index_de_rangement_dans_la_liste \
) \
); \
\
LISTER_LA_LISTE_DES_COORDONNEES_DES_POINTS(x,y,z); \
LISTER_LA_LISTE_DES_VITESSES_DES_POINTS; \
\
CAL2(Prin1(" IDENTITE=%d" \
,identite_de_la_sphere_courante \
) \
); \
/* Le 20210104113820, je rapelle qu'ici, on liste les points APRES (voir a ce propos */ \
/* 'v $xrv/champs_5.26$I 20210104114710'). */ \
\
CAL2(Prin1(" MASSE=%.^^^" \
,masse_de_la_sphere_courante \
) \
); \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
LISTER_LA_LISTE_DES_ENERGIES_CINETIQUES_DES_POINTS; \
\
LISTER_LA_LISTE_DES_RAYONS_DES_POINTS(Arayon); \
/* On notera le 20110712103021 que l'edition des rayons apres toutes les transformations */ \
/* ne donne pas 'champ_RAYON' (c'est-a-dire les rayons tels qu'ils ont ete specifies en */ \
/* tant qu'arguments des '$X') mais 'Arayon' c'est-a-dire 'rayon_reel_absolu' (voir a ce */ \
/* propos 'v $xrv/champs_5.26$I MEMORISATION_D_UN_POINT'). */ \
LISTER_LA_LISTE_DES_COULEURS_DES_POINTS(rouge,verte,bleue); \
\
FERMER_L_ENTREE_COURANTE_DE_LA_LISTE; \
/* Introduit le 20210104115459... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCR(index_de_rangement_dans_la_liste,I); \
/* Et preparation du rangement du point suivant... */ \
Eblock \
ATes \
Bblock \
Test(IFET(IZEQ(Arayon),IZEQ(Vrayon))) \
Bblock \
/* A compter du 1995071000, un rayon nul n'est plus une erreur, mais correspond a une */ \
/* demande de non affichage d'un point... */ \
Eblock \
ATes \
Bblock \
/* Un rayon negatif reste, bien entendu, une erreur... */ \
PRINT_ERREUR("la sphere representative du point courant a une composante ou un Rayon negatif"); \
CAL1(Prer3("centre................=(%g,%g,%g)\n",x,y,z)); \
CAL1(Prer1("Rayon Absolu..........=%g\n",Arayon)); \
CAL1(Prer1("Rayon de Visualisation=%g\n",Vrayon)); \
CAL1(Prer3("couleur...............=(%g,%g,%g)\n",rouge,verte,bleue)); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("trop de points sont a visualiser"); \
CAL1(Prer1("index du point courant=%d\n" \
,index_de_rangement_dans_la_liste \
) \
); \
CAL1(Prer1("index du dernier point autorise=%d\n" \
,LSTX(PREMIER_POINT_DES_LISTES,NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES) \
) \
); \
Eblock \
ETes \
Eblock \
/* Rangement d'un point dans la liste... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E D E T R I D ' U N E L I S T E D E P O I N T S */
/* F O N C T I O N N A N T E N ' N ' A U C A R R E : */
/* */
/*************************************************************************************************************************************/
#define TRI_D_UNE_LISTE_DE_POINTS_VERSION_N_AU_CARRE(premier_point_de_la_liste,dernier_point_de_la_liste) \
Bblock \
TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE(liste_des_Z \
,liste_des_index \
,premier_point_de_la_liste \
,dernier_point_de_la_liste \
,ACCES_LISTE \
); \
Eblock \
/* Tri d'une liste de points avec une methode en 'N' au carre... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E D E T R I D ' U N E L I S T E D E P O I N T S */
/* F O N C T I O N N A N T E N ' N x L O G ( N ) ' : */
/* */
/*************************************************************************************************************************************/
#define TRI_D_UNE_LISTE_DE_POINTS_VERSION_N_LOG_N(premier_point_de_la_liste,dernier_point_de_la_liste) \
Bblock \
TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_LOG_N(liste_des_Z \
,liste_des_index \
,premier_point_de_la_liste \
,dernier_point_de_la_liste \
,ACCES_LISTE \
); \
Eblock \
/* Tri d'une liste de points avec une methode en 'N*log(N)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E D E T R I D ' U N E L I S T E D E P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define LISTER_LA_LISTE_DES_POINTS_AVANT_LE_TRI \
FAUX
DEFV(Local,DEFV(Logical,INIT(lister_la_liste_des_points_avant_le_tri,LISTER_LA_LISTE_DES_POINTS_AVANT_LE_TRI)));
#define LISTER_LA_LISTE_DES_POINTS_APRES_LE_TRI \
FAUX
DEFV(Local,DEFV(Logical,INIT(lister_la_liste_des_points_apres_le_tri,LISTER_LA_LISTE_DES_POINTS_APRES_LE_TRI)));
/* Ces indicateurs permettent de controler l'edition de la liste avant et/ou apres le tri. */
#define LISTER_LA_LISTE_DES_POINTS_AVANT_ET_OU_APRES_LE_TRI(lister_la_liste,premier_point_de_la_liste,dernier_point_de_la_liste) \
Bblock \
Test(IL_FAUT(lister_la_liste)) \
Bblock \
DEFV(Int,INIT(index_d_edition_de_la_liste,UNDEF)); \
DoIn(index_d_edition_de_la_liste,premier_point_de_la_liste,dernier_point_de_la_liste,I) \
Bblock \
CAL2(Prin5("index=%d point=%g X=%+.^^^ Y=%+.^^^ Z=%+.^^^\n" \
,index_d_edition_de_la_liste \
,ACCES_LISTE(liste_des_index,index_d_edition_de_la_liste) \
,ACCES_LISTE(liste_des_X,ACCES_LISTE(liste_des_index,index_d_edition_de_la_liste)) \
,ACCES_LISTE(liste_des_Y,ACCES_LISTE(liste_des_index,index_d_edition_de_la_liste)) \
,ACCES_LISTE(liste_des_Z,ACCES_LISTE(liste_des_index,index_d_edition_de_la_liste)) \
) \
); \
/* Suite au probleme 'v $xiirs/$Fnota 20040330115702', le 20040410152458, le format "%+.16g" */ \
/* a ete remplace par "%+.18g" afin de montrer d'infimes differences... */ \
/* */ \
/* Le 20060105160451, le format "18g" est conserve a cause de la modification decrite */ \
/* ci-dessus. Finalement, le 20060109092901 le format "18g" est devenu "^^g" suite a la */ \
/* modification 'v $xig/fonct$vv$FON 20060105164504' qui demande par defaut 18 chiffres... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Listage des points d'une liste avant et/ou apres le tri (introduit le 20040409155653). */
#define TRI_D_UNE_LISTE_DE_POINTS(premier_point_de_la_liste,dernier_point_de_la_liste) \
Bblock \
LISTER_LA_LISTE_DES_POINTS_AVANT_ET_OU_APRES_LE_TRI(lister_la_liste_des_points_avant_le_tri \
,premier_point_de_la_liste \
,dernier_point_de_la_liste \
); \
\
begin_nouveau_block \
/* Introduit le 20170609083403... */ \
Bblock \
DEFV(Logical,INIT(effectivement__utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE \
,utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE \
) \
); \
/* Introduit le 20170609081838... */ \
\
Test(IL_FAUT(choisir_automatiquement_la_methode_de_tri_d_une_liste_de_points)) \
/* Possibilite introduite le 20170608082613... */ \
Bblock \
Test(IFLE(NBRE(premier_point_de_la_liste,dernier_point_de_la_liste) \
,NOMBRE_RAISONNABLE_MAXIMAL_D_ELEMENTS_DANS_TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE \
) \
) \
Bblock \
EGAL(effectivement__utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE,VRAI); \
/* On peut utiliser le tri suivant la methode 'N*N' */ \
Eblock \
ATes \
Bblock \
EGAL(effectivement__utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE,FAUX); \
/* Il faut utiliser le tri suivant la methode 'N*log(N)' */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(effectivement__utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE)) \
Bblock \
TRI_D_UNE_LISTE_DE_POINTS_VERSION_N_AU_CARRE(premier_point_de_la_liste \
,dernier_point_de_la_liste \
); \
/* Tri suivant la methode 'N*N'... */ \
Eblock \
ATes \
Bblock \
TRI_D_UNE_LISTE_DE_POINTS_VERSION_N_LOG_N(premier_point_de_la_liste \
,dernier_point_de_la_liste \
); \
/* Tri suivant la methode 'N*log(N)'... */ \
Eblock \
ETes \
Eblock \
end_nouveau_block \
\
LISTER_LA_LISTE_DES_POINTS_AVANT_ET_OU_APRES_LE_TRI(lister_la_liste_des_points_apres_le_tri \
,premier_point_de_la_liste \
,dernier_point_de_la_liste \
); \
Eblock \
/* Tri d'une liste de points. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E D E C A L C U L D ' U N P S E U D O - C E N T R E D E G R A V I T E */
/* E T D E T R I D ' U N E L I S T E D E P O I N T S */
/* S U R L A C O O R D O N N E E ' Z ' D ' A R R I E R E E N A V A N T */
/* P O U R L U T T E R E F F I C A C E M E N T C O N T R E L ' A L I A S I N G : */
/* */
/*************************************************************************************************************************************/
#define TRIER_LA_LISTE_DES_POINTS \
VRAI
DEFV(Local,DEFV(Logical,INIT(trier_la_liste_des_points,TRIER_LA_LISTE_DES_POINTS)));
/* Cet indicateur permet de ne pas faire le tri des points par 'Z' croissant, ce qui */
/* permet pour des tests, ou lorsqu'il y a trop de points, de travailler en un temps */
/* raisonnable... */
#define CHOISIR_AUTOMATIQUEMENT_LA_METHODE_DE_TRI_D_UNE_LISTE_DE_POINTS \
FAUX
DEFV(Local,DEFV(Logical,INIT(choisir_automatiquement_la_methode_de_tri_d_une_liste_de_points
,CHOISIR_AUTOMATIQUEMENT_LA_METHODE_DE_TRI_D_UNE_LISTE_DE_POINTS
)
)
);
/* Cet indicateur introduit le 20170608082613 premet de choisir automatiquement la methode */
/* de tri ('N au carre' ou 'N*log(N)') suivant le nombre d'elements a trier... */
#define UTILISER_LE_TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE \
VRAI
DEFV(Local,DEFV(Logical,INIT(utiliser_le_tri_d_une_liste_quelconque_VERSION_N_AU_CARRE
,UTILISER_LE_TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE
)
)
);
/* Cet indicateur permet de choisir entre le tri en 'N au carre' (qui conserve l'ordre */
/* des points possedant la meme clef de tri (la coordonnee 'Z')) et le tri en 'N*log(N)' */
/* qui ne conserve pas cet ordre... */
#define CALCUL_DU_PSEUDO_CENTRE_DE_GRAVITE_ET_TRI_D_UNE_LISTE_DE_POINTS \
Bblock \
DECR(index_de_rangement_dans_la_liste,I); \
/* Retour sur le dernier point memorise dans la liste... */ \
\
Test(IL_FAUT(editer_le_pseudo_centre_de_gravite)) \
Bblock \
/* Cas ou il faut editer (et donc calculer) le pseudo-centre de gravite. */ \
DEFV(Int,INIT(index_calcul_du_pseudo_centre_de_gravite,UNDEF)); \
/* Index de calcul du pseudo-centre de gravite. */ \
DEFV(Float,INIT(X_pseudo_centre_de_gravite,FZERO)); \
DEFV(Float,INIT(Y_pseudo_centre_de_gravite,FZERO)); \
DEFV(Float,INIT(Z_pseudo_centre_de_gravite,FZERO)); \
DEFV(Float,INIT(ponderation_pseudo_centre_de_gravite,FZERO)); \
/* Pour calculer les coordonnees {X,Y,Z} du pseudo-centre de gravite. */ \
\
DoIn(index_calcul_du_pseudo_centre_de_gravite,PREMIER_POINT_DES_LISTES,index_de_rangement_dans_la_liste,I) \
Bblock \
DEFV(Float,INIT(ponderation_point_courant \
,MUL2(ACCES_LISTE(liste_des_GPOND,index_calcul_du_pseudo_centre_de_gravite) \
,LIZ6(facteur_NEUTRE_du_pseudo_centre_de_gravite \
,FU \
,facteur_MASSE_du_pseudo_centre_de_gravite \
,ACCES_LISTE(liste_des_MASSE,index_calcul_du_pseudo_centre_de_gravite) \
,facteur_RAYON_du_pseudo_centre_de_gravite \
,PUI3(ACCES_LISTE(liste_des_aRAYON,index_calcul_du_pseudo_centre_de_gravite)) \
,facteur_ROUGE_du_pseudo_centre_de_gravite \
,NEUT(ACCES_LISTE(liste_des_ROUGE,index_calcul_du_pseudo_centre_de_gravite)) \
,facteur_VERTE_du_pseudo_centre_de_gravite \
,NEUT(ACCES_LISTE(liste_des_VERTE,index_calcul_du_pseudo_centre_de_gravite)) \
,facteur_BLEUE_du_pseudo_centre_de_gravite \
,NEUT(ACCES_LISTE(liste_des_BLEUE,index_calcul_du_pseudo_centre_de_gravite)) \
) \
) \
) \
); \
/* Ponderation du point courant. */ \
/* */ \
/* Le 20070227143947, 'PUIX(...,TRI_DIMENSIONNEL)' fut remplace par 'PUI3(...)'. */ \
\
INCR(X_pseudo_centre_de_gravite \
,MUL2(ponderation_point_courant,ACCES_LISTE(liste_des_X,index_calcul_du_pseudo_centre_de_gravite)) \
); \
INCR(Y_pseudo_centre_de_gravite \
,MUL2(ponderation_point_courant,ACCES_LISTE(liste_des_Y,index_calcul_du_pseudo_centre_de_gravite)) \
); \
INCR(Z_pseudo_centre_de_gravite \
,MUL2(ponderation_point_courant,ACCES_LISTE(liste_des_Z,index_calcul_du_pseudo_centre_de_gravite)) \
); \
INCR(ponderation_pseudo_centre_de_gravite \
,NEUT(ponderation_point_courant) \
); \
/* Calcul "progressif" du pseudo-centre de gravite. */ \
Eblock \
EDoI \
\
EGAL(X_pseudo_centre_de_gravite,DIVZ(X_pseudo_centre_de_gravite,ponderation_pseudo_centre_de_gravite)); \
EGAL(Y_pseudo_centre_de_gravite,DIVZ(Y_pseudo_centre_de_gravite,ponderation_pseudo_centre_de_gravite)); \
EGAL(Z_pseudo_centre_de_gravite,DIVZ(Z_pseudo_centre_de_gravite,ponderation_pseudo_centre_de_gravite)); \
/* Calcul "definitif" du pseudo-centre de gravite. */ \
\
CAL2(Prin1("periode=%d" \
,numero_de_la_periode_courante \
) \
); \
CAL2(Prin3(" CENTRE_DE_GRAVITE=(XG=%+.^^^,YG=%+.^^^,ZG=%+.^^^)" \
,X_pseudo_centre_de_gravite \
,Y_pseudo_centre_de_gravite \
,Z_pseudo_centre_de_gravite \
) \
); \
/* Edition du pseudo-centre de gravite, mais ATTENTION, ses coordonnees sont exprimees */ \
/* dans [0,1]x[0,1]x[0,1] et non pas dans l'espace physique qu'on ne connait pratiquement */ \
/* plus ici a cause des transformations diverses et variees. Ensuite, si l'on souhaite */ \
/* visualiser le centre de gravite, on pourra utiliser 'v $xrv/particule.10$K' a condition */ \
/* de choisir judicieusement ses parametres ('v $xrv/particule.10$K coordonnees_dans_0_1'). */ \
/* On notera de plus que grace au programme 'v $xrv/SOUS.11$K', il est possible de placer */ \
/* tout ensemble de particules {X,Y,Z} dans un referentiel lie a leur centre de gravite 'G' */ \
/* {XG,YG,ZG} en visualisant le fichier des {X-XG,Y-YG,Z-ZG}. */ \
/* */ \
/* Le 20060105160451, le format "16g" est passe a "^^g" pour plus de souplesse... */ \
/* */ \
/* Le 20091123123512, le format "^^g" est passe a "^^^" pour plus de souplesse... */ \
\
CAL2(Prin0("\n")); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(trier_la_liste_des_points)) \
Bblock \
/* Cas ou il faut trier les points... */ \
Test(IFGT(index_de_rangement_dans_la_liste,PREMIER_POINT_DES_LISTES)) \
Bblock \
/* Cas ou il y a au moins deux points : il faut donc trier... */ \
Test(IL_FAUT(ajuster_automatiquement_profondeur_minimale_et_profondeur_maximale)) \
Bblock \
DEFV(Int,INIT(index_d_ajustement_automatique,UNDEF)); \
/* Index d'ajustement... */ \
EGAL(profondeur_minimale_reelle,F_INFINI); \
EGAL(profondeur_maximale_reelle,F_MOINS_L_INFINI); \
/* Initialisation du processus d'ajustement automatique des extrema de la coordonnee 'Z'. */ \
DoIn(index_d_ajustement_automatique,PREMIER_POINT_DES_LISTES,index_de_rangement_dans_la_liste,I) \
Bblock \
EGAL(profondeur_minimale_reelle \
,MIN2(profondeur_minimale_reelle \
,ACCES_LISTE(liste_des_Z,index_d_ajustement_automatique) \
) \
); \
EGAL(profondeur_maximale_reelle \
,MAX2(profondeur_maximale_reelle \
,ACCES_LISTE(liste_des_Z,index_d_ajustement_automatique) \
) \
); \
/* Ajustement automatique des extrema de la coordonnee 'Z'. */ \
/* */ \
/* Je note le 20050419173039 qu'il y a certainement redondance entre ces deux definitions */ \
/* {profondeur_minimale_reelle,profondeur_maximale_reelle} et ce qui fut introduit le */ \
/* 20050419141059 a savoir {minimum_de_la_coordonnee_Z,maximum_de_la_coordonnee_Z}, mais */ \
/* dans le doute, je conserve les deux mecanismes... */ \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
TRI_D_UNE_LISTE_DE_POINTS(PREMIER_POINT_DES_LISTES \
,index_de_rangement_dans_la_liste \
); \
/* Tri suivant la methode choisie ('N*N' ou 'N*log(N)'). */ \
Eblock \
ATes \
Bblock \
/* Cas ou il n'y a qu'un point : le tri n'est alors pas vraiment utile... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
/* Cas ou le tri des points n'est pas demande : gare aux problemes d'aliasing... */ \
Eblock \
ETes \
Eblock \
/* Tri d'une liste de points, pour laquelle on suppose que l'index designant le dernier */ \
/* element (soit 'index_de_rangement_dans_la_liste') pointe sur la premiere entree libre, */ \
/* et non pas sur le dernier element range... */