/*************************************************************************************************************************************/
/* */
/* P A R A D O X E D E G E N Z L I N G : */
/* */
/* */
/* Author of '$xrk/ParadoxeG.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20050422084953). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define UTILISER_UN_ESPACE_DE_PARAMETRAGE_TRIDIMENSIONNEL \
VRAI \
/* Doit-on utiliser un espace de parametrage tridimensionnel ('VRAI') ou bidimensionnel */ \
/* ('FAUX') ? Ceci a ete introduit le 20001211162430. */
#define UTILISER_LE_GENERATEUR_A_PERIODICITE_PARAMETRABLE \
FAUX \
/* Doit-on utiliser le generateur a periodicite parametrable ('VRAI') ou l'autre ('FAUX') ? */
#define GRAINE \
PARE(1789) \
/* Definition du generateur aleatoire... */
#define DEPHASAGE_INITIAL \
ZERO \
/* Nombre de valeurs aleatoires a generer initialement en aveugle de facon a se dephaser */ \
/* dans la liste des valeurs aleatoires generees (introduit le 20021028090331). */
#define EXTERIEUR_DE_L_ESPACE \
GRIS_0
#define INTERIEUR_DE_L_ESPACE \
GRIS_8
/* Definition de l'interieur et de l'exterieur de l'Espace de generation des droites */
/* aleatoires. */
#define L_ESPACE_EST_L_ESPACE_DE_TIRAGE_ALEATOIRE \
FAUX \
/* L'espace est-il l'espace de tirage aleatoire ('VRAI') ou bien definit-il les points */ \
/* eux-memes (ceci a ete introduit le 20050425084205) ? La valeur par defaut est passee de */ \
/* 'VRAI' a 'FAUX' le 20050621094753 car il est finalement plus utile d'analyser des images */ \
/* de points generees a l'exterieur de ce programme et qui sont arbitraires et par exemple */ \
/* non necessairement aleatoires... */
#define NOMBRE_DE_POINTS \
VINGT \
/* Nombre de points du processus aleatoire... */
#define EDITER_TOUTES_LES_INFORMATIONS \
FAUX \
/* Faut-il editer toutes les informations ('VRAI') ou uniquement les angles ('FAUX') ? Ceci */ \
/* a ete introduit le 20050423232748. */
#define EDITER_LES_COORDONNEES \
FAUX
#define EDITER_LES_ANGLES \
VRAI
#define EDITER_LES_ANGLES_EN_RADIANS \
VRAI
#define EDITER_LES_STATISTIQUES \
FAUX
/* Controle des diverses editions, la possibilite d'editer les angles en degres plutot */
/* qu'en radians ayant ete introduite le 20050710123922... */
#define NIVEAU_DES_DROITES \
GRIS_2
#define NIVEAU_DES_SEGMENTS \
GRIS_8
/* Niveaux de trace des droites et des segments... */
#include xci/valeurs.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/valeurs.02.I"
#define GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire,borne_inferieure,borne_superieure) \
Bblock \
Test(IL_NE_FAUT_PAS(utiliser_le_generateur_a_periodicite_parametrable)) \
Bblock \
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] et parametree */ \
/* par le point courant de l'espace de parametrage : */ \
EGAL(valeur_aleatoire \
,COND(IL_NE_FAUT_PAS(utiliser_un_espace_de_parametrage_tridimensionnel) \
,rdnI2D(ADRESSE(point_courant_de_l_espace_de_parametrage_2D) \
,graine \
,RDN_INIT_AND_GENERE \
,borne_inferieure,borne_superieure \
) \
,rdnI3D(ADRESSE(point_courant_de_l_espace_de_parametrage_3D) \
,graine \
,RDN_INIT_AND_GENERE \
,borne_inferieure,borne_superieure \
) \
) \
); \
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] et parametree */ \
/* par le point courant de l'espace de parametrage. */ \
\
SPIRALE_INITIALISATION; \
/* Initialisation dynamique de 'spirale_nombre_de_points_a_traiter'. */ \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage_2D,x) \
,ASD1(point_courant_de_l_espace_de_parametrage_2D,y) \
); \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage_3D,x) \
,ASD1(point_courant_de_l_espace_de_parametrage_3D,y) \
); \
/* Deplacement du point courant de la spirale de l'espace de parametrage, et ce en restant */ \
/* dans un plan Z=constante (Zmin)... */ \
SPIRALE_PARCOURS; \
/* Parcours de la spirale avec rotation eventuelle de PI/2 du bras courant... */ \
Eblock \
ATes \
Bblock \
EGAL(valeur_aleatoire \
,rdn_iteratif_cercle() \
); \
EGAL(valeur_aleatoire \
,DENO(valeur_aleatoire,borne_inferieure,borne_superieure) \
); \
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] non parametree */ \
/* par le point courant de l'espace de parametrage. */ \
Eblock \
ETes \
Eblock
#define ACCES_POINT(point) \
IdTb1(liste_des_points \
,INDX(point,PREMIER_POINT) \
,nombre_de_points \
) \
/* Acces a un point de numero donne 'point'... */
#define EQUATION_D_UNE_DROITE(point1,point2,delta_X,delta_Y,coefficient_a,coefficient_b,coefficient_c) \
Bblock \
Test(IFET(IFNE(ASD1(ACCES_POINT(point1),x),ASD1(ACCES_POINT(point2),x)) \
,IFNE(ASD1(ACCES_POINT(point1),y),ASD1(ACCES_POINT(point2),y)) \
) \
) \
Bblock \
EGAL(coefficient_a \
,NEGA(DIVI(delta_Y,delta_X)) \
); \
EGAL(coefficient_b \
,FU \
); \
EGAL(coefficient_c \
,NEGA(LIZ2(coefficient_a,CHOI(ASD1(ACCES_POINT(point1),x),ASD1(ACCES_POINT(point2),x)) \
,coefficient_b,CHOI(ASD1(ACCES_POINT(point1),y),ASD1(ACCES_POINT(point2),y)) \
) \
) \
); \
Eblock \
ATes \
Bblock \
Test(IFEQ(ASD1(ACCES_POINT(point1),x),ASD1(ACCES_POINT(point2),x))) \
Bblock \
EGAL(coefficient_a \
,FU \
); \
EGAL(coefficient_b \
,FZERO \
); \
EGAL(coefficient_c \
,NEGA(CHOI(ASD1(ACCES_POINT(point1),x),ASD1(ACCES_POINT(point2),x))) \
); \
/* Cas d'une droite verticale... */ \
Eblock \
ATes \
Bblock \
Test(IFEQ(ASD1(ACCES_POINT(point1),y),ASD1(ACCES_POINT(point2),y))) \
Bblock \
EGAL(coefficient_a \
,FZERO \
); \
EGAL(coefficient_b \
,FU \
); \
EGAL(coefficient_c \
,NEGA(CHOI(ASD1(ACCES_POINT(point1),y),ASD1(ACCES_POINT(point2),y))) \
); \
/* Cas d'une droite horizontale... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'equation de la droite ne peut etre determinee"); \
CAL1(Prer2("point1={%f,%f}\n",ASD1(ACCES_POINT(point1),x),ASD1(ACCES_POINT(point1),y))); \
CAL1(Prer2("point1={%f,%f}\n",ASD1(ACCES_POINT(point2),x),ASD1(ACCES_POINT(point2),y))); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
Eblock
#define TRACE_D_UN_SEGMENT(point1,point2) \
Bblock \
SET_CURSOR(_____cNORMALISE_OX(ASD1(ACCES_POINT(point1),x)) \
,_____cNORMALISE_OY(ASD1(ACCES_POINT(point1),y)) \
,_____cNORMALISE_OZ(Zmin) \
); \
gA; \
\
SET_CURSOR(_____cNORMALISE_OX(ASD1(ACCES_POINT(point2),x)) \
,_____cNORMALISE_OY(ASD1(ACCES_POINT(point2),y)) \
,_____cNORMALISE_OZ(Zmin) \
); \
gB; \
/* Trace du segment. */ \
Eblock
#define TRACE_D_UNE_DROITE(coefficient_A,coefficient_B,coefficient_C) \
Bblock \
Test(IFET(IZNE(coefficient_A),IZNE(coefficient_B))) \
/* Cas d'une droite oblique : */ \
Bblock \
DEFV(Float,INIT(coefficient_A_renormalise,NEGA(DIVI(coefficient_A,coefficient_B)))); \
DEFV(Float,INIT(coefficient_B_renormalise,NEGA(DIVI(coefficient_C,coefficient_B)))); \
DEFV(Int,INIT(Y_pour_Xmin,UNDEF)); \
DEFV(Int,INIT(X_pour_Ymin,UNDEF)); \
EGAL(Y_pour_Xmin,AXPB(coefficient_A_renormalise,Xmin,coefficient_B_renormalise)); \
EGAL(X_pour_Ymin,DIVI(SOUS(Ymin,coefficient_B_renormalise),coefficient_A_renormalise)); \
\
Test(IFGE(Y_pour_Xmin,Ymin)) \
Bblock \
SET_CURSOR(_____cNORMALISE_OX(Xmin) \
,_____cNORMALISE_OY(Y_pour_Xmin) \
,_____cNORMALISE_OZ(Zmin) \
); \
Eblock \
ATes \
Bblock \
DEFV(Int,INIT(Y_pour_Xmax,AXPB(coefficient_A_renormalise,Xmax,coefficient_B_renormalise))); \
\
SET_CURSOR(_____cNORMALISE_OX(Xmax) \
,_____cNORMALISE_OY(Y_pour_Xmax) \
,_____cNORMALISE_OZ(Zmin) \
); \
Eblock \
ETes \
\
gA; \
\
Test(IFGE(X_pour_Ymin,Xmin)) \
Bblock \
SET_CURSOR(_____cNORMALISE_OX(X_pour_Ymin) \
,_____cNORMALISE_OY(Ymin) \
,_____cNORMALISE_OZ(Zmin) \
); \
Eblock \
ATes \
Bblock \
DEFV(Int,INIT(X_pour_Ymax,DIVI(SOUS(Ymax,coefficient_B_renormalise),coefficient_A_renormalise))); \
\
SET_CURSOR(_____cNORMALISE_OX(X_pour_Ymax) \
,_____cNORMALISE_OY(Ymax) \
,_____cNORMALISE_OZ(Zmin) \
); \
Eblock \
ETes \
\
gB; \
/* Trace de la droite. */ \
Eblock \
ATes \
Bblock \
Test(IZEQ(coefficient_A)) \
/* Cas d'une droite horizontale : */ \
Bblock \
DEFV(Int,INIT(Y_horizontal,NEGA(DIVI(coefficient_C,coefficient_B)))); \
SET_CURSOR(_____cNORMALISE_OX(Xmin) \
,_____cNORMALISE_OY(Y_horizontal) \
,_____cNORMALISE_OZ(Zmin) \
); \
\
gA; \
\
SET_CURSOR(_____cNORMALISE_OX(Xmax) \
,_____cNORMALISE_OY(Y_horizontal) \
,_____cNORMALISE_OZ(Zmin) \
); \
\
gB; \
/* Trace de la droite. */ \
Eblock \
ATes \
Bblock \
Test(IZEQ(coefficient_B)) \
/* Cas d'une droite verticale : */ \
Bblock \
DEFV(Int,INIT(X_horizontal,NEGA(DIVI(coefficient_C,coefficient_A)))); \
SET_CURSOR(_____cNORMALISE_OX(X_horizontal) \
,_____cNORMALISE_OY(Ymin) \
,_____cNORMALISE_OZ(Zmin) \
); \
\
gA; \
\
SET_CURSOR(_____cNORMALISE_OX(X_horizontal) \
,_____cNORMALISE_OY(Ymax) \
,_____cNORMALISE_OZ(Zmin) \
); \
\
gB; \
/* Trace de la droite. */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la droite ne peut etre tracee"); \
CAL1(Prer3("(a,b,c)={%f,%f,%f}\n",coefficient_A,coefficient_B,coefficient_C)); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A D O X E D E G E N Z L I N G : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageE),NOM_PIPE));
/* Definition de l'Espace de generation des droites aleatoires. */
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom de l'image ou montrer les droites... */
DEFV(genere_p,INIT(exterieur_de_l_espace,EXTERIEUR_DE_L_ESPACE));
DEFV(genere_p,INIT(interieur_de_l_espace,INTERIEUR_DE_L_ESPACE));
/* Definition de l'interieur et de l'exterieur de l'Espace de generation des droites */
/* aleatoires. On notera au passage que 'exterieur_de_l_espace' ne sert a rien mais */
/* qu'il est conserve par symetrie avec ce qui est fait avec le Domaine... */
DEFV(Logical,INIT(l_espace_est_l_espace_de_tirage_aleatoire,L_ESPACE_EST_L_ESPACE_DE_TIRAGE_ALEATOIRE));
/* L'espace est-il l'espace de tirage aleatoire ('VRAI') ou bien definit-il les points */
/* eux-memes (ceci a ete introduit le 20050425084205) ? La valeur par defaut est passee de */
/* 'VRAI' a 'FAUX' le 20050621094753 car il est finalement plus utile d'analyser des images */
/* de points generees a l'exterieur de ce programme et qui sont arbitraires et par exemple */
/* non necessairement aleatoires... */
DEFV(Logical,INIT(utiliser_un_espace_de_parametrage_tridimensionnel,UTILISER_UN_ESPACE_DE_PARAMETRAGE_TRIDIMENSIONNEL));
/* Doit-on utiliser un espace de parametrage tridimensionnel ('VRAI') ou bidimensionnel */
/* ('FAUX') ? Ceci a ete introduit le 20001211162430. */
DEFV(Logical,INIT(utiliser_le_generateur_a_periodicite_parametrable,UTILISER_LE_GENERATEUR_A_PERIODICITE_PARAMETRABLE));
/* Doit-on utiliser le generateur a periodicite parametrable ('VRAI') ou l'autre ('FAUX') ? */
DEFV(Positive,INIT(dephasage_initial,DEPHASAGE_INITIAL));
/* Nombre de valeurs aleatoires a generer initialement en aveugle de facon a se dephaser */
/* dans la liste des valeurs aleatoires generees (introduit le 20021028090331). */
DEFV(Int,INIT(graine,GRAINE));
/* Definition du generateur aleatoire... */
DEFV(Int,INIT(nombre_de_points,NOMBRE_DE_POINTS));
/* Nombre de points du processus aleatoire... */
DEFV(Logical,INIT(editer_toutes_les_informations,EDITER_TOUTES_LES_INFORMATIONS));
/* Faut-il editer toutes les informations ('VRAI') ou uniquement les angles ('FAUX') ? Ceci */
/* a ete introduit le 20050423232748. */
DEFV(Logical,INIT(editer_les_coordonnees,EDITER_LES_COORDONNEES));
DEFV(Logical,INIT(editer_les_angles,EDITER_LES_ANGLES));
DEFV(Logical,INIT(editer_les_angles_en_radians,EDITER_LES_ANGLES_EN_RADIANS));
DEFV(Logical,INIT(editer_les_statistiques,EDITER_LES_STATISTIQUES));
/* Controle des diverses editions, la possibilite d'editer les angles en degres plutot */
/* qu'en radians ayant ete introduite le 20050710123922... */
DEFV(genere_p,INIT(niveau_des_droites,NIVEAU_DES_DROITES));
DEFV(genere_p,INIT(niveau_des_segments,NIVEAU_DES_SEGMENTS));
/* Niveaux de trace des droites et des segments... */
#include xci/valeurs.03.I"
/*..............................................................................................................................*/
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("Ipoint_anti_aliase_segment_____compatibilite_20110420=""compatibilite_20110420="
,Ipoint_anti_aliase_segment_____compatibilite_20110420
);
/* Parametre introduit le 20110420145531... */
GET_ARGUMENT_C("imageE=""E=""A=",nom_imageE);
GET_ARGUMENT_C("R=",nom_imageR);
GET_ARGUMENT_P("exte=",exterieur_de_l_espace);
GET_ARGUMENT_P("inte=",interieur_de_l_espace);
GET_ARGUMENT_L("aleatoire=",l_espace_est_l_espace_de_tirage_aleatoire);
GET_ARGUMENT_N("deterministe=",l_espace_est_l_espace_de_tirage_aleatoire);
GET_ARGUMENT_I("points=""Pnombre=",nombre_de_points);
/* Le 20050623153703, "nombre=" a ete remplace par "Pnombre=" (double definition...). */
GET_ARGUMENT_L("tridimensionnel=""3D=",utiliser_un_espace_de_parametrage_tridimensionnel);
GET_ARGUMENT_L("periodique=",utiliser_le_generateur_a_periodicite_parametrable);
GET_ARGUMENT_I("graine=""g=",graine);
GET_ARGUMENT_L("affiner_rdn=",rdnIFnD_____affiner_la_generation);
GET_ARGUMENT_L("iterer_rdn=",rdnIFnD_____iterer_la_generation);
GET_ARGUMENT_F("x=""X=",ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,x));
GET_ARGUMENT_F("y=""Y=",ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,y));
GET_ARGUMENT_F("pente=""Ad=",rdn_iteratif_cercle_____pente_A_de_la_droite);
/* Le 20050623153703, "A=" a ete remplace par "Ad=" (double definition...). */
GET_ARGUMENT_F("ordonnee=""Bd=",rdn_iteratif_cercle_____ordonnee_a_l_origine_B_de_la_droite);
/* Le 20050623153703, "B=" a ete remplace par "Bd=" (double definition...). */
GET_ARGUMENT_F("pd=""pas_droite=",rdn_iteratif_cercle_____pas_de_parcours_de_la_droite);
/* Le 20050623153703, "pas=" a ete remplace par "pas_droite=" et "pd=" (double def...). */
GET_ARGUMENT_F("rayon=",rdn_iteratif_cercle_____rayon_minimal_des_cercles);
GET_ARGUMENT_F("facteur=""extension=",rdn_iteratif_cercle_____facteur_d_extension_du_rayon_des_cercles);
GET_ARGUMENT_I("saut=",rdn_iteratif_cercle_____nombre_de_nombres_aleatoires_a_sauter);
GET_ARGUMENT_F("nombre=",rdn_iteratif_cercle_____nombre_aleatoire_courant);
GET_ARGUMENT_L("premiere_racine=",rdn_iteratif_cercle_____prendre_la_premiere_racine);
GET_ARGUMENT_I("dephasage=",dephasage_initial);
GET_ARGUMENT_L("informations=""editer=",editer_toutes_les_informations);
GET_ARGUMENT_L("coordonnees=",editer_les_coordonnees);
GET_ARGUMENT_L("angles=",editer_les_angles);
GET_ARGUMENT_L("radians=",editer_les_angles_en_radians);
GET_ARGUMENT_N("degres=",editer_les_angles_en_radians);
GET_ARGUMENT_L("statistiques=",editer_les_statistiques);
GET_ARGUMENT_P("droites=",niveau_des_droites);
GET_ARGUMENT_P("segments=",niveau_des_segments);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
/* Cette procedure fut introduite le 20061226190122... */
)
);
Test(IFET(IL_FAUT(editer_toutes_les_informations),IL_NE_FAUT_PAS(editer_les_coordonnees)))
Bblock
EGAL(editer_les_coordonnees,VRAI);
/* Afin de vraiment tout editer... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(editer_toutes_les_informations),IL_NE_FAUT_PAS(editer_les_angles)))
Bblock
EGAL(editer_les_angles,VRAI);
/* Afin de vraiment tout editer... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(editer_toutes_les_informations),IL_NE_FAUT_PAS(editer_les_statistiques)))
Bblock
EGAL(editer_les_statistiques,VRAI);
/* Afin de vraiment tout editer... */
Eblock
ATes
Bblock
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA1,nom_imageE))))
/* Definition de l'Espace de generation des droites aleatoires ('A1'). */
Bblock
DEFV(pointF_2D,DdTb1(POINTERs
,liste_des_points
,nombre_de_points
,tMalo(MUL2(nombre_de_points,SIZE(pointF_2D)),pointF_2D)
)
);
DEFV(Int,INIT(point,PREMIER_POINT));
DEFV(Int,INIT(point_A,UNDEF));
DEFV(Int,INIT(point_B,UNDEF));
DEFV(Int,INIT(point_C,UNDEF));
DEFV(Int,INIT(point_D,UNDEF));
/* Definition de la liste des points et des index d'acces... */
DEFV(Int,INIT(nombre_de_points_dans_l_Espace,ZERO));
/* Nombre total de cas traites parmi 'nombre_de_points'... */
DEFV(pointI_2D,point_courant_de_l_espace_de_parametrage_2D);
DEFV(pointI_3D,point_courant_de_l_espace_de_parametrage_3D);
/* Point courant d'un espace abstrait servant a parametrer le generateur d'evenements. */
SPIRALE_DEFINITION_GENERALE(SPIRALE_DELTA_HORIZONTAL_GLOBAL,SPIRALE_DELTA_VERTICAL_GLOBAL)
/* Donnees de generation d'une spirale de parcours d'un espace abstrait bidimensionnel */
/* de parametrage de la generation des evenements. */
/* ATTENTION : jusqu'au 20010926155950, il y avait ici : */
/* */
/* SPIRALE_REINITIALISATION_BRAS_ET_DELTAS; */
/* */
/* qui provenait d'un "copier-coller" un peu large. Il ne sert a rien et a ete supprime... */
SPIRALE_VALIDATION;
/* Validation des pas de parcours (pasX,pasY) de l'Espace abstrait de parametrage du */
/* generateur d'evenements. */
INITIALISATION_POINT_2D(point_courant_de_l_espace_de_parametrage_2D,Xmin,Ymin);
INITIALISATION_POINT_3D(point_courant_de_l_espace_de_parametrage_3D,Xmin,Ymin,Zmin);
/* Initialisation de l'espace de parametrage independante du format de l'image, puisque le */
/* point 'min' n'en depend pas... */
Test(IL_NE_FAUT_PAS(utiliser_le_generateur_a_periodicite_parametrable))
Bblock
Repe(dephasage_initial)
Bblock
DEFV(Float,INIT(valeur_aleatoire_sautee,FLOT__UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire_sautee
,COORDONNEE_BARYCENTRIQUE_MINIMALE
,COORDONNEE_BARYCENTRIQUE_MAXIMALE
);
/* Et on saute eventuellement les 'dephasage_initial' premieres valeurs aleatoires... */
Eblock
ERep
Eblock
ATes
Bblock
Test(IZNE(dephasage_initial))
Bblock
PRINT_ERREUR("le dephasage est incompatible avec l'utilisation du generateur aleatoire periodique");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
CALi(FgERASE());
SET_ANTI_ALIASING(VRAI);
/* Mise en place systematique de l'anti-aliasing... */
EGAL(point,PREMIER_POINT);
Test(EST_VRAI(l_espace_est_l_espace_de_tirage_aleatoire))
Bblock
CALS(Ihistogramme(ImageA1));
/* Calcul de l'histogramme de l'Espace (introduit le 20050502092743). */
Test(IFLT(ACCES_HISTOGRAMME(interieur_de_l_espace),NEUT(nombre_de_points)))
/* Test introduit le 20050502092743... On notera qu'il serait peut-etre logique de */
/* remplacer 'NEUT(...)' par un 'GRO?(...)' car, en effet, il convient que l'Espace de */
/* tirage aleatoire ait beaucoup plus de points que demandes (l'Espace de tirage aleatoire */
/* doit etre evidemment plus dense que l'ensemble des points aleatoires eux-memes...). */
Bblock
PRINT_ERREUR("l'Espace de tirage aleatoire n'est pas assez dense");
CAL1(Prer2("(%d points aleatoires sont demandes et l'Espace de tirage aleatoire n'en contient que %d)\n"
,nombre_de_points
,ACCES_HISTOGRAMME(interieur_de_l_espace)
)
);
Eblock
ATes
Bblock
Eblock
ETes
Tant(IFLT(nombre_de_points_dans_l_Espace,nombre_de_points))
Bblock
DEFV(pointI_2D,point_courant_aleatoire);
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(ASD1(point_courant_aleatoire,x),FLOT(Xmin),FLOT(Xmax));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(ASD1(point_courant_aleatoire,y),FLOT(Ymin),FLOT(Ymax));
/* Definition du point courant de la droite aleatoire... */
Test(IFEQ(load_point(ImageA1,ASD1(point_courant_aleatoire,x),ASD1(point_courant_aleatoire,y))
,interieur_de_l_espace
)
)
Bblock
/* Cas ou le point courant est dans l'Espace, on le conserve : */
TRANSFERT_POINT_2D(ACCES_POINT(point),point_courant_aleatoire);
INCR(nombre_de_points_dans_l_Espace,I);
INCR(point,I);
Eblock
ATes
Bblock
/* Cas ou le point courant est a l'exterieur de l'Espace, on l'ignore... */
Eblock
ETes
Eblock
ETan
Eblock
ATes
Bblock
begin_image
Bblock
Test(IFEQ(load_point(ImageA1,X,Y)
,interieur_de_l_espace
)
)
Bblock
/* Cas ou le point courant est dans l'Espace, on le conserve : */
Test(IFLT(nombre_de_points_dans_l_Espace,nombre_de_points))
/* S'il y a encore de la place... */
Bblock
INITIALISATION_POINT_2D(ACCES_POINT(point),X,Y);
INCR(nombre_de_points_dans_l_Espace,I);
INCR(point,I);
Eblock
ATes
Bblock
PRINT_ERREUR("il y a trop de points dans l'Espace et seuls les premiers seront utilises");
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou le point courant est a l'exterieur de l'Espace, on l'ignore... */
Eblock
ETes
Eblock
end_image
Test(IFLT(nombre_de_points_dans_l_Espace,nombre_de_points))
/* Test introduit le 20050502092743... */
Bblock
PRINT_ERREUR("il n'y a pas assez de points dans l'Espace");
CAL1(Prer2("(%d points avaient ete demandes et seulement %d ont ete trouves)\n"
,nombre_de_points
,nombre_de_points_dans_l_Espace
)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(IL_FAUT(editer_les_coordonnees))
Bblock
DoIn(point,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points_dans_l_Espace),I)
Bblock
CAL2(Prin2("point aleatoire..................... : X=%f Y=%f\n"
,ASD1(ACCES_POINT(point),x)
,ASD1(ACCES_POINT(point),y)
)
);
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
DoIn(point_A,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points_dans_l_Espace),I)
Bblock
DoIn(point_B,point_A,LSTX(PREMIER_POINT,nombre_de_points_dans_l_Espace),I)
Bblock
DoIn(point_C,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points_dans_l_Espace),I)
Bblock
DoIn(point_D,point_C,LSTX(PREMIER_POINT,nombre_de_points_dans_l_Espace),I)
Bblock
Test(I4ET(IFLT(point_A,point_B),IFLT(point_C,point_D),IFLE(point_A,point_C),IFLE(point_B,point_D)))
Bblock
/* Cas ou les points {A,B} et {C,D} definissent chacun une droite : */
/* */
/* ATTENTION : on notera que malgre tout deux points d'index differents, peuvent etre */
/* geometriquement confondus (meme s'il s'agit d'un evenement rare...), mais cela est */
/* detecte plus loin en testant la nullite de 'delta_X_??' et de 'delta_Y_AB??"... */
/* */
/* ATTENTION : on notera que ces tests sont destines a eviter de traiter deux fois le meme */
/* couple de droite, mais dans un ordre different... */
DEFV(Float,INIT(delta_X_AB,SOUS(ASD1(ACCES_POINT(point_B),x),ASD1(ACCES_POINT(point_A),x))));
DEFV(Float,INIT(delta_Y_AB,SOUS(ASD1(ACCES_POINT(point_B),y),ASD1(ACCES_POINT(point_A),y))));
DEFV(Float,INIT(delta_X_CD,SOUS(ASD1(ACCES_POINT(point_D),x),ASD1(ACCES_POINT(point_C),x))));
DEFV(Float,INIT(delta_Y_CD,SOUS(ASD1(ACCES_POINT(point_D),y),ASD1(ACCES_POINT(point_C),y))));
DEFV(Float,INIT(coefficient_a_de_AB,FLOT__UNDEF));
DEFV(Float,INIT(coefficient_b_de_AB,FLOT__UNDEF));
DEFV(Float,INIT(coefficient_c_de_AB,FLOT__UNDEF));
DEFV(Float,INIT(coefficient_a_de_CD,FLOT__UNDEF));
DEFV(Float,INIT(coefficient_b_de_CD,FLOT__UNDEF));
DEFV(Float,INIT(coefficient_c_de_CD,FLOT__UNDEF));
Test(IFET(IFOU(IZNE(delta_X_AB),IZNE(delta_Y_AB))
,IFOU(IZNE(delta_X_CD),IZNE(delta_Y_CD))
)
)
Bblock
/* Cas ou les points 'A' et 'B' ('C' et 'D' respectivement) sont geometriquement */
/* differents : */
EQUATION_D_UNE_DROITE(point_A
,point_B
,delta_X_AB
,delta_Y_AB
,coefficient_a_de_AB
,coefficient_b_de_AB
,coefficient_c_de_AB
);
/* Definition de la droite 'AB'. */
EQUATION_D_UNE_DROITE(point_C
,point_D
,delta_X_CD
,delta_Y_CD
,coefficient_a_de_CD
,coefficient_b_de_CD
,coefficient_c_de_CD
);
/* Definition de la droite 'CD'. */
Test(IFOU(IFNE(coefficient_a_de_AB,coefficient_a_de_CD)
,IFNE(coefficient_b_de_AB,coefficient_b_de_CD)
)
)
Bblock
/* Cas ou les deux droites 'AB' et 'CD' sont distinctes et non paralleles : */
DEFV(Float,INIT(angle_entre_AB_et_CD
,SOUA(ATAN(delta_Y_AB,delta_X_AB)
,ATAN(delta_Y_CD,delta_X_CD)
)
)
);
/* Angle dans [0,2.pi] entre les vecteurs 'AB' et 'CD'. */
Test(IFGT(angle_entre_AB_et_CD,PI))
Bblock
EGAL(angle_entre_AB_et_CD,SOUS(angle_entre_AB_et_CD,PI));
/* L'angle entre les vecteurs 'AB' et 'CD' est d'abord ramene dans [0,pi], */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGT(angle_entre_AB_et_CD,PI_SUR_2))
Bblock
EGAL(angle_entre_AB_et_CD,SOUS(PI,angle_entre_AB_et_CD));
/* Puis dans [0,pi/2]... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(editer_les_angles))
Bblock
Test(IL_FAUT(editer_toutes_les_informations))
Bblock
CAL2(Prin4("points.............................. : %d %d %d %d\n"
,point_A,point_B
,point_C,point_D
)
);
CAL2(Prin4("droite 'AB'......................... : {A={%f,%f},B={%f,%f}}"
,ASD1(ACCES_POINT(point_A),x),ASD1(ACCES_POINT(point_A),y)
,ASD1(ACCES_POINT(point_B),x),ASD1(ACCES_POINT(point_B),y)
)
);
CAL2(Prin3(" a=%f b=%f c=%f\n"
,coefficient_a_de_AB
,coefficient_b_de_AB
,coefficient_c_de_AB
)
);
CAL2(Prin4("droite 'CD'......................... : {C={%f,%f},D={%f,%f}}"
,ASD1(ACCES_POINT(point_C),x),ASD1(ACCES_POINT(point_C),y)
,ASD1(ACCES_POINT(point_D),x),ASD1(ACCES_POINT(point_D),y)
)
);
CAL2(Prin3(" a=%f b=%f c=%f\n"
,coefficient_a_de_CD
,coefficient_b_de_CD
,coefficient_c_de_CD
)
);
Test(IL_FAUT(editer_les_angles_en_radians))
Bblock
CAL2(Prin0("angle (en radians).................. : "));
Eblock
ATes
Bblock
CAL2(Prin0("angle (en degres)................... : "));
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT
,valeurs_signees
,".*"
,format_d_edition
,"\n"
)
)
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,COND(IL_FAUT(editer_les_angles_en_radians)
,NEUT(angle_entre_AB_et_CD)
,CONVERSION_RADIANS_EN_DEGRES(angle_entre_AB_et_CD)
)
)
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE_chaine(nom_imageR,NOM_PIPE))
Bblock
Test(IFNE(niveau_des_droites,NOIR))
Bblock
SET_COULEURS(NOIR,niveau_des_droites);
TRACE_D_UNE_DROITE(coefficient_a_de_AB
,coefficient_b_de_AB
,coefficient_c_de_AB
);
TRACE_D_UNE_DROITE(coefficient_a_de_CD
,coefficient_b_de_CD
,coefficient_c_de_CD
);
/* Trace des droites 'AB' et 'CD'... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE(niveau_des_segments,NOIR))
Bblock
SET_COULEURS(niveau_des_droites,niveau_des_segments);
TRACE_D_UN_SEGMENT(point_A,point_B);
TRACE_D_UN_SEGMENT(point_C,point_D);
/* Trace des segments 'AB' et 'CD'... */
/* */
/* ATTENTION : je note le 20050627155730 qu'etant donne que l'on trace ci-dessus les */
/* droites 'AB' et 'CD', puis ici et maintenant les segments 'AB' et 'CD', ces derniers */
/* sont donc traces deux fois (une fois sur les droites et une seconde fois en tant que */
/* tel...). Cela a donc des consequences desastreuses en ce qui concerne l'anti-aliasing */
/* des segments 'AB' et 'CD'. C'est pourquoi, a cette date, le : */
/* */
/* SET_COULEURS(NOIR,niveau_des_segments); */
/* */
/* ci-dessus a ete modifie pour arranger considerablement les choses (meme si cela n'est */
/* pas parfait...). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou les deux droites 'AB' et 'CD' sont confondues... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou les points 'A' et 'B' ('C' et 'D' respectivement) sont geometriquement */
/* confondus... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou les points {A,B} ou {C,D} ne definissent pas une droite... */
Eblock
ETes
Eblock
EDoI
Eblock
EDoI
Eblock
EDoI
Eblock
EDoI
Test(IL_FAUT(editer_les_statistiques))
Bblock
CAL2(Prin0("\n\n"));
CAL2(Prin1("nombre de points demandes........... = %d\n",nombre_de_points));
CAL2(Prin1("nombre de points dans l'Espace...... = %d\n",nombre_de_points_dans_l_Espace));
CAL2(Prin0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE_chaine(nom_imageR,NOM_PIPE))
Bblock
CALi(Iupdate_image(nom_imageR,ImageG));
Eblock
ATes
Bblock
Eblock
ETes
FdTb1(liste_des_points,nombre_de_points,pointF_2D,ADRESSE_PLUS_DEFINIE);
/* Definition de la liste des points... */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
RETU_Commande;
Eblock
ECommande