/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U P A R C O U R S D ' U N E I M A G E : */
/* */
/* */
/* Author of '$xiii/begin_end$DEF' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19870000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V E R I F I C A T I O N S D E L ' I N D E X A T I O N : */
/* */
/*************************************************************************************************************************************/
#ifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
# define VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Procedure introduite le 20170713115708... */
#Aifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
# define VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE \
Bblock \
Test(I3ET(IFEQ(translationX,TraX) \
,IFEQ(translationY,TraY) \
,IFEQ(translationZ,TraZ) \
) \
) \
Bblock \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("c'est l'INDEXATION SIMPLIFIEE qui est a priori utilisee ici (3)"); \
CAL1(Prer3("les options ['%s','%s','%s'] sont donc ineffectives\n" \
,ENTREE_ARGUMENT_translationX \
,ENTREE_ARGUMENT_translationY \
,ENTREE_ARGUMENT_translationZ \
) \
); \
Eblock \
ETes \
Eblock \
/* Procedure introduite le 20170713115708... */ \
/* */ \
/* On notera a cette date que certaines librairies ont pu etre generees en mode */ \
/* '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', alors que tous les '$K's utiles ne l'ont */ \
/* pas ete ainsi. Pour ces '$K's les arguments {ENTREE_ARGUMENT_translation?} existent */ \
/* donc, alors que les variables 'translation?' ne sont pas utilisees puisque les fonctions */ \
/* 'Findice_?(...)' ne seront pas referencees dans ces librairies. C'est pourquoi ces */ \
/* messages sont edites (alors qu'ils avaient ete supprimes pendant quelques heures...). */
#Eifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D E T E M P S ( ' T ' ) : */
/* */
/*************************************************************************************************************************************/
/* Definitions introduites le 20171219103002... */
#define Gbegin_tempsQ(fonction_de_parcours,temps_minimal,temps_maximal,pas_temps,type_temps,select_pas) \
/* ATTENTION, 'begin_tempsQ(...)' redefinit 'pasT' avec 'pas_temps'... */ \
Bblock \
DEFV(type_temps,INIT(EnTete_de_sauvegardM ## T,T)); \
/* Memorisation d'une eventuelle coordonnee 'T' anterieure (une coordonnee 'T' de niveau */ \
/* "bas" est donc a cause de cela definie dans '$xiii/Images$STR'). Ainsi, la procedure */ \
/* 'begin_tempsQ(...)' a un fonctionnement recursif... */ \
DEFV(type_temps,INIT(pasT_global,pasT)); \
/* Memorisation de 'pasT' tel qu'il etait avant (en particulier a cause de 'X-Window'). */ \
DEFV(type_temps,INIT(EnTete_de_sauvegardM ## pasT,select_pas(pas_temps,PasT))); \
/* Sauvegarde temporaire du pas demande pour la temps ; ce passage par une variable */ \
/* intermediaire est rendu necessaire par le fait que la variable locale que l'on va creer */ \
/* par la suite pour le pas de la temps porte le meme nom que le pas global ('pasT'), */ \
/* et donc pour initialiser cette variable locale proprement dans les cas frequents ou */ \
/* elle doit prendre la valeur globale 'pasT', et comme on ne pourrait ecrire pasT=pasT, */ \
/* on passe par l'intermediaire 'SavA_____pasT'... */ \
Bblock \
DEFV(type_temps,INIT(T,CAST(type_temps,UNDEF))); \
/* Definition de la temps decrivant l'axe 'OT'. */ \
DEFV(type_temps,INIT(Tmin_begin_tempsQ,temps_minimal)); \
DEFV(type_temps,INIT(Tmax_begin_tempsQ,temps_maximal)); \
/* Definition de l'axe 'OT' courant. */ \
DEFV(type_temps,INIT(pasT,EnTete_de_sauvegardM ## pasT)); \
/* Definition du pas courant de la temps decrivant l'axe 'OT' ; on choisit le meme nom */ \
/* que la variable globale 'pasT' afin que les macros 'SUCT', 'PRET' et 'INTT' fonctionnent */ \
/* correctement meme a l'exterieur de 'begin_tempsQ'/'end_tempsQ'... */ \
\
fonction_de_parcours(T \
,Tmin_begin_tempsQ \
,Tmax_begin_tempsQ \
,pasT \
) \
Bblock
#define Gend_tempsQ(fin_de_fonction_de_parcours,type_temps) \
Eblock \
fin_de_fonction_de_parcours \
Eblock \
Eblock
#define begin_tempsQ(fonction_de_parcours,temps_minimal,temps_maximal,pas_temps) \
Gbegin_tempsQ(fonction_de_parcours,temps_minimal,temps_maximal,pas_temps,Int,MAX2)
#define end_tempsQ(fin_de_fonction_de_parcours) \
Gend_tempsQ(fin_de_fonction_de_parcours,Int)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D E P R O F O N D E U R ( ' Z ' ) : */
/* */
/*************************************************************************************************************************************/
#define Gbegin_fuiteQ(fonction_de_parcours,profondeur_minimale,profondeur_maximale,pas_profondeur,type_profondeur,select_pas) \
/* ATTENTION, 'begin_fuiteQ(...)' redefinit 'pasZ' avec 'pas_profondeur'... */ \
Bblock \
DEFV(type_profondeur,INIT(EnTete_de_sauvegardM ## Z,Z)); \
/* Memorisation d'une eventuelle coordonnee 'Z' anterieure (une coordonnee 'Z' de niveau */ \
/* "bas" est donc a cause de cela definie dans '$xiii/Images$STR'). Ainsi, la procedure */ \
/* 'begin_fuiteQ(...)' a un fonctionnement recursif... */ \
DEFV(type_profondeur,INIT(pasZ_global,pasZ)); \
/* Memorisation de 'pasZ' tel qu'il etait avant (en particulier a cause de 'X-Window'). */ \
DEFV(type_profondeur,INIT(EnTete_de_sauvegardM ## pasZ,select_pas(pas_profondeur,PasZ))); \
/* Sauvegarde temporaire du pas demande pour la profondeur ; ce passage par une variable */ \
/* intermediaire est rendu necessaire par le fait que la variable locale que l'on va creer */ \
/* par la suite pour le pas de la profondeur porte le meme nom que le pas global ('pasZ'), */ \
/* et donc pour initialiser cette variable locale proprement dans les cas frequents ou */ \
/* elle doit prendre la valeur globale 'pasZ', et comme on ne pourrait ecrire pasZ=pasZ, */ \
/* on passe par l'intermediaire 'SavA_____pasZ'... */ \
Bblock \
DEFV(type_profondeur,INIT(Z,CAST(type_profondeur,UNDEF))); \
/* Definition de la profondeur decrivant l'axe 'OZ'. */ \
DEFV(type_profondeur,INIT(Zmin_begin_fuiteQ,profondeur_minimale)); \
DEFV(type_profondeur,INIT(Zmax_begin_fuiteQ,profondeur_maximale)); \
/* Definition de l'axe 'OZ' courant. */ \
DEFV(type_profondeur,INIT(pasZ,EnTete_de_sauvegardM ## pasZ)); \
/* Definition du pas courant de la profondeur decrivant l'axe 'OZ' ; on choisit le meme nom */ \
/* que la variable globale 'pasZ' afin que les macros 'SUCZ', 'PREZ' et 'INTZ' fonctionnent */ \
/* correctement meme a l'exterieur de 'begin_fuiteQ'/'end_fuiteQ'... */ \
\
fonction_de_parcours(Z \
,Zmin_begin_fuiteQ \
,Zmax_begin_fuiteQ \
,pasZ \
) \
Bblock
#define Gend_fuiteQ(fin_de_fonction_de_parcours,type_profondeur) \
Eblock \
fin_de_fonction_de_parcours \
Eblock \
Eblock
#define begin_fuiteQ(fonction_de_parcours,profondeur_minimale,profondeur_maximale,pas_profondeur) \
Gbegin_fuiteQ(fonction_de_parcours,profondeur_minimale,profondeur_maximale,pas_profondeur,Int,MAX2)
#define end_fuiteQ(fin_de_fonction_de_parcours) \
Gend_fuiteQ(fin_de_fonction_de_parcours,Int)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D E C O L O N N E S ( ' Y ' ) : */
/* */
/*************************************************************************************************************************************/
#define Gbegin_colonneQ(fonction_de_parcours,ordonnee_minimale,ordonnee_maximale,pas_ordonnee,type_ordonnee,select_pas) \
/* ATTENTION, 'begin_colonneQ(...)' redefinit 'pasY' avec 'pas_ordonnee'... */ \
Bblock \
DEFV(type_ordonnee,INIT(EnTete_de_sauvegardM ## Y,Y)); \
/* Memorisation d'une eventuelle coordonnee 'Y' anterieure (une coordonnee 'Y' de niveau */ \
/* "bas" est donc a cause de cela definie dans '$xiii/Images$STR'). Ainsi, la procedure */ \
/* 'begin_colonneQ(...)' a un fonctionnement recursif... */ \
DEFV(type_ordonnee,INIT(pasY_global,pasY)); \
/* Memorisation de 'pasY' tel qu'il etait avant (en particulier a cause de 'X-Window'). */ \
DEFV(type_ordonnee,INIT(EnTete_de_sauvegardM ## pasY,select_pas(pas_ordonnee,PasY))); \
/* Sauvegarde temporaire du pas demande pour l'ordonnee ; ce passage par une variable */ \
/* intermediaire est rendu necessaire par le fait que la variable locale que l'on va creer */ \
/* par la suite pour le pas de l'ordonnee porte le meme nom que le pas global (soit 'pasY'), */ \
/* et donc pour initialiser cette variable locale proprement dans les cas frequents ou */ \
/* elle doit prendre la valeur globale 'pasY', et comme on ne pourrait ecrire pasY=pasY, */ \
/* on passe par l'intermediaire 'SavA_____pasY'... */ \
Bblock \
DEFV(type_ordonnee,INIT(Y,CAST(type_ordonnee,UNDEF))); \
/* Definition de l'ordonnee decrivant l'axe 'OY'. */ \
DEFV(type_ordonnee,INIT(Ymin_begin_colonneQ,ordonnee_minimale)); \
DEFV(type_ordonnee,INIT(Ymax_begin_colonneQ,ordonnee_maximale)); \
/* Definition de l'axe 'OY' courant. */ \
DEFV(type_ordonnee,INIT(pasY,EnTete_de_sauvegardM ## pasY)); \
/* Definition du pas courant de l'ordonnee decrivant l'axe 'OY' ; on choisit le meme nom */ \
/* que la variable globale 'pasY' afin que les macros 'SUCY', 'PREY' et 'INTY' fonctionnent */ \
/* correctement meme a l'exterieur de 'begin_colonneQ'/'end_colonneQ'... */ \
\
fonction_de_parcours(Y \
,Ymin_begin_colonneQ \
,Ymax_begin_colonneQ \
,pasY \
) \
Bblock
#define Gend_colonneQ(fin_de_fonction_de_parcours,type_ordonnee) \
Eblock \
fin_de_fonction_de_parcours \
Eblock \
Eblock
#define begin_colonneQ(fonction_de_parcours,ordonnee_minimale,ordonnee_maximale,pas_ordonnee) \
Gbegin_colonneQ(fonction_de_parcours,ordonnee_minimale,ordonnee_maximale,pas_ordonnee,Int,MAX2)
#define end_colonneQ(fin_de_fonction_de_parcours) \
Gend_colonneQ(fin_de_fonction_de_parcours,Int)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D E L I G N E S ( ' X ' ) : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, il est imperatif que 'begin_ligneQ' utilise la fonction 'DoIn(...)', ce qui */
/* signifie que les coordonnees sont traitees de facon croissante (de 'Xmin' a 'Xmax'), car */
/* en effet, certains algorithmes utilisent ce fait ; c'est en particulier le cas de la */
/* fonction 'Istereogramme(...)' de 'v $xiii/quad_image$FON' lorsqu'a lieu le decalage de la */
/* texture du stereogramme. */
#define Gbegin_ligneQ(fonction_de_parcours,abscisse_minimale,abscisse_maximale,pas_abscisse,type_abscisse,select_pas) \
/* ATTENTION, 'begin_ligneQ(...)' redefinit 'pasX' avec 'pas_abscisse'... */ \
Bblock \
DEFV(type_abscisse,INIT(EnTete_de_sauvegardM ## X,X)); \
/* Memorisation d'une eventuelle coordonnee 'X' anterieure (une coordonnee 'X' de niveau */ \
/* "bas" est donc a cause de cela definie dans '$xiii/Images$STR'). Ainsi, la procedure */ \
/* 'begin_ligneQ(...)' a un fonctionnement recursif... */ \
DEFV(type_abscisse,INIT(pasX_global,pasX)); \
/* Memorisation de 'pasX' tel qu'il etait avant (en particulier a cause de 'X-Window'). */ \
DEFV(type_abscisse,INIT(EnTete_de_sauvegardM ## pasX,select_pas(pas_abscisse,PasX))); \
/* Sauvegarde temporaire du pas demande pour l'abscisse ; ce passage par une variable */ \
/* intermediaire est rendu necessaire par le fait que la variable locale que l'on va creer */ \
/* par la suite pour le pas de l'abscisse porte le meme nom que le pas global (soit 'pasX'), */ \
/* et donc pour initialiser cette variable locale proprement dans les cas frequents ou */ \
/* elle doit prendre la valeur globale 'pasX', et comme on ne pourrait ecrire pasX=pasX, */ \
/* on passe par l'intermediaire 'SavA_____pasX'... */ \
Bblock \
DEFV(type_abscisse,INIT(X,CAST(type_abscisse,UNDEF))); \
/* Definition de l'abscisse decrivant l'axe 'OX'. */ \
DEFV(type_abscisse,INIT(Xmin_begin_ligneQ,abscisse_minimale)); \
DEFV(type_abscisse,INIT(Xmax_begin_ligneQ,abscisse_maximale)); \
/* Definition de l'axe 'OX' courant. */ \
DEFV(type_abscisse,INIT(pasX,EnTete_de_sauvegardM ## pasX)); \
/* Definition du pas courant de l'abscisse decrivant l'axe 'OX' ; on choisit le meme nom */ \
/* que la variable globale 'pasX' afin que les macros 'SUCX', 'PREX' et 'INTX' fonctionnent */ \
/* correctement meme a l'exterieur de 'begin_ligneQ'/'end_ligneQ'... */ \
/* definition du pas courant de l'abscisse decrivant l'axe 'OX'. */ \
\
fonction_de_parcours(X \
,Xmin_begin_ligneQ \
,Xmax_begin_ligneQ \
,pasX \
) \
Bblock
#define Gend_ligneQ(fin_de_fonction_de_parcours,type_abscisse) \
Eblock \
fin_de_fonction_de_parcours \
Eblock \
Eblock
#define begin_ligneQ(fonction_de_parcours,abscisse_minimale,abscisse_maximale,pas_abscisse) \
Gbegin_ligneQ(fonction_de_parcours,abscisse_minimale,abscisse_maximale,pas_abscisse,Int,MAX2)
#define end_ligneQ(fin_de_fonction_de_parcours) \
Gend_ligneQ(fin_de_fonction_de_parcours,Int)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D ' I M A G E S : */
/* */
/*************************************************************************************************************************************/
#define Gbegin_imageQ(DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas,DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas) \
Gbegin_colonneQ(DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas) \
Bblock \
/* ATTENTION, on ne peut mettre ici : */ \
/* */ \
/* B_PROGRESSION_DES_BEGIN_END(Y,DoYmin,DIMENSION(DoYmin,DoYmax)); */ \
/* */ \
/* car a priori rien n'est standard, et en particulier les dimensions. On verra a ce propos */ \
/* 'v $xiipf/fonction.3$FON Fparcours_circulaire_d_une_spirale_carree' ou le "pave" */ \
/* parcouru alors n'a rien a voir avec les images au format courant... */ \
Gbegin_ligneQ(DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas) \
Bblock
#define Gend_imageQ(EDoY,typeY,EDoX,typeX) \
Eblock \
Gend_ligneQ(EDoX,typeX) \
Eblock \
Gend_colonneQ(EDoY,typeY)
#define begin_imageQ(DoY,DoYmin,DoYmax,DoYpas,DoX,DoXmin,DoXmax,DoXpas) \
Gbegin_imageQ(DoY,DoYmin,DoYmax,DoYpas,Int,MAX2 \
,DoX,DoXmin,DoXmax,DoXpas,Int,MAX2 \
)
#define end_imageQ(EDoY,EDoX) \
Gend_imageQ(EDoY,Int \
,EDoX,Int \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D ' A L B U M : */
/* */
/*************************************************************************************************************************************/
#define Gbegin_albumQ(DoZ,DoZmin,DoZmax,DoZpas,typeZ,sZpas,DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas,DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas) \
Gbegin_fuiteQ(DoZ,DoZmin,DoZmax,DoZpas,typeZ,sZpas) \
Bblock \
/* ATTENTION, on ne peut mettre ici : */ \
/* */ \
/* B_PROGRESSION_DES_BEGIN_END(Z,DoZmin,DIMENSION(DoZmin,DoZmax)); */ \
/* */ \
/* car a priori rien n'est standard, et en particulier les dimensions. */ \
Gbegin_colonneQ(DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas) \
Bblock \
Gbegin_ligneQ(DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas) \
Bblock
#define Gend_albumQ(EDoZ,typeZ,EDoY,typeY,EDoX,typeX) \
Eblock \
Gend_ligneQ(EDoX,typeX) \
Eblock \
Gend_colonneQ(EDoY,typeY) \
Eblock \
Gend_fuiteQ(EDoZ,typeZ)
#define begin_albumQ(DoZ,DoZmin,DoZmax,DoZpas,DoY,DoYmin,DoYmax,DoYpas,DoX,DoXmin,DoXmax,DoXpas) \
Gbegin_albumQ(DoZ,DoZmin,DoZmax,DoZpas,Int,MAX2 \
,DoY,DoYmin,DoYmax,DoYpas,Int,MAX2 \
,DoX,DoXmin,DoXmax,DoXpas,Int,MAX2 \
)
#define end_albumQ(EDoZ,EDoY,EDoX) \
Gend_albumQ(EDoZ,Int \
,EDoY,Int \
,EDoX,Int \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S G E N E R A L E S D ' H Y P E R - A L B U M : */
/* */
/*************************************************************************************************************************************/
/* Definitions introduites le 20171219103002... */
#define Gbegin_hyper_albumQ(DoT,DoTmin,DoTmax,DoTpas,typeT,sTpas \
,DoZ,DoZmin,DoZmax,DoZpas,typeZ,sZpas \
,DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas \
,DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas \
) \
Gbegin_tempsQ(DoT,DoTmin,DoTmax,DoTpas,typeT,sTpas) \
Bblock \
Gbegin_fuiteQ(DoZ,DoZmin,DoZmax,DoZpas,typeZ,sZpas) \
Bblock \
Gbegin_colonneQ(DoY,DoYmin,DoYmax,DoYpas,typeY,sYpas) \
Bblock \
Gbegin_ligneQ(DoX,DoXmin,DoXmax,DoXpas,typeX,sXpas) \
Bblock
#define Gend_hyper_albumQ(EDoT,typeT,EDoZ,typeZ,EDoY,typeY,EDoX,typeX) \
Eblock \
Gend_ligneQ(EDoX,typeX) \
Eblock \
Gend_colonneQ(EDoY,typeY) \
Eblock \
Gend_fuiteQ(EDoZ,typeZ) \
Eblock \
Gend_tempsQ(EDoT,typeT)
#define begin_hyper_albumQ(DoT,DoTmin,DoTmax,DoTpas,DoZ,DoZmin,DoZmax,DoZpas,DoY,DoYmin,DoYmax,DoYpas,DoX,DoXmin,DoXmax,DoXpas) \
Gbegin_hyper_albumQ(DoT,DoTmin,DoTmax,DoTpas,Int,MAX2 \
,DoZ,DoZmin,DoZmax,DoZpas,Int,MAX2 \
,DoY,DoYmin,DoYmax,DoYpas,Int,MAX2 \
,DoX,DoXmin,DoXmax,DoXpas,Int,MAX2 \
)
#define end_hyper_albumQ(EDoT,EDoZ,EDoY,EDoX) \
Gend_hyper_albumQ(EDoT,Int \
,EDoZ,Int \
,EDoY,Int \
,EDoX,Int \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D E T E M P S ( ' T ' ) : */
/* */
/*************************************************************************************************************************************/
/* Definitions introduites le 20171219103002... */
#define begin_temps \
begin_tempsQ(DoIn,Tmin,NEUT(Tmax),pasT)
#define end_temps \
end_tempsQ(EDoI)
#define begin_temps_back \
begin_tempsQ(DoDe,Tmin,INTT(Tmax),pasT) \
/* ATTENTION, il est imperatif de partir de 'INTZ(Zmax)' afin que 'begin_temps' */ \
/* et 'begin_temps_back' atteignent les memes points lorsque 'pasZ' ne vaut pas 'PasZ'... */
#define end_temps_back \
end_tempsQ(EDoD)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D E P R O F O N D E U R ( ' Z ' ) : */
/* */
/*************************************************************************************************************************************/
#define begin_fuite \
begin_fuiteQ(DoIn,Zmin,NEUT(Zmax),pasZ)
#define end_fuite \
end_fuiteQ(EDoI)
#define begin_fuite_back \
begin_fuiteQ(DoDe,Zmin,INTZ(Zmax),pasZ) \
/* ATTENTION, il est imperatif de partir de 'INTZ(Zmax)' afin que 'begin_fuite' */ \
/* et 'begin_fuite_back' atteignent les memes points lorsque 'pasZ' ne vaut pas 'PasZ'... */
#define end_fuite_back \
end_fuiteQ(EDoD)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D E C O L O N N E ( ' Y ' ) : */
/* */
/*************************************************************************************************************************************/
#define begin_colonne \
begin_colonneQ(DoIn,Ymin,NEUT(Ymax),pasY)
#define end_colonne \
end_colonneQ(EDoI)
#define begin_colonne_back \
begin_colonneQ(DoDe,Ymin,INTY(Ymax),pasY) \
/* ATTENTION, il est imperatif de partir de 'INTY(Ymax)' afin que 'begin_colonne' */ \
/* et 'begin_colonne_back' atteignent les memes points lorsque 'pasY' ne vaut pas 'PasY'... */ \
/* */ \
/* L'introduction de 'INTY(...)' a ete faite le 19961211000000 a cause de la fonction */ \
/* 'Iliste_image(...)' ('v $xiida/fonction$FON Iliste_image') utilisee par la commande */ \
/* '$xci/liste$K' qui, lorsqu'il y a '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI' (ce qui est */ \
/* le cas a cette date sur '$LACT27' et sur '$LACT28'), ne fonctionnait plus correctement ; */ \
/* en effet, les fonctions 'Icomplementation(...)' et 'Imove(...)' ('v $xci/liste$K') */ \
/* utilisent 'begin_colonne' alors que 'Iliste_image(...)' utilisaient 'begin_colonne_back'. */ \
/* Si '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI' les procedures 'INDEXATION_OX(...)' et */ \
/* 'INDEXATION_OY(...)' ('v $xiii/Images$DEF INDEXATION_O.') sont "simplistes" et ne */ \
/* ramenent par les coordonnees sur le maillage defini par {pasX,pasY} (ce qui est fait */ \
/* dans le cas contraire par 'Findice_X(...)' et 'Findice_Y(...)'). Ainsi, les fonctions */ \
/* 'Icomplementation(...)' et 'Imove(...)' d'une part, et 'Iliste_image(...)' d'autre part, */ \
/* n'accedaient pas aux memes points... */
#define end_colonne_back \
end_colonneQ(EDoD)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D E L I G N E ( ' X ' ) : */
/* */
/*************************************************************************************************************************************/
#define begin_ligne \
begin_ligneQ(DoIn,Xmin,NEUT(Xmax),pasX)
#define end_ligne \
end_ligneQ(EDoI)
/* ATTENTION, il est imperatif que 'begin_ligne' utilise la fonction 'DoIn(...)', ce qui */
/* signifie que les coordonnees sont traitees de facon croissante (de 'Xmin' a 'Xmax'), car */
/* en effet, certains algorithmes utilisent ce fait ; c'est en particulier le cas de la */
/* fonction 'Istereogramme(...)' de '$xiii/tri_image$FON' lorsqu'a lieu le decalage de la */
/* texture du stereogramme... */
#define begin_ligne_back \
begin_ligneQ(DoDe,Xmin,INTX(Xmax),pasX) \
/* ATTENTION, il est imperatif de partir de 'INTX(Xmax)' afin que 'begin_ligne' */ \
/* et 'begin_ligne_back' atteignent les memes points lorsque 'pasX' ne vaut pas 'PasX'... */
#define end_ligne_back \
end_ligneQ(EDoD)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D ' I M A G E ( ' Y ' P U I S ' X ' ) : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, il est imperatif que 'begin_image' utilise la fonction 'DoIn(...)', ce qui */
/* signifie que les coordonnees sont traitees de facon croissante (de 'Xmin' a 'Xmax' et */
/* de 'Ymin' a 'Ymax'), car en effet, certains algorithmes utilisent ce fait. Depuis le */
/* 19961004093218, c'est le cas de toutes les fonctions qui utilisent 'Pconvolution(...)' */
/* dans 'v $xiii/di_image$FON'... */
#define Pbegin_image(Bprogression) \
VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE; \
/* Verification introduite le 20170713121225... */ \
begin_colonne \
Bblock \
BLOC(Bprogression); \
\
begin_ligne \
Bblock
#define Pend_image(Eprogression) \
Eblock \
end_ligne \
\
BLOC(Eprogression); \
Eblock \
end_colonne
/* Introduit sous cette forme le 20170520092906 afin de faire que l'edition de la */
/* progression des {begin,end} ne soit disponible que pour les cas exceptionnels */
/* (via "_AvecEditionProgression") ou cela est justifie (par exemple : convolution,... */
/* Voir a ce propos 'v $xiii/di_image$FON _AvecEditionProgression'). */
#define begin_image \
Pbegin_image(BLOC(VIDE;))
#define end_image \
Pend_image(BLOC(VIDE;))
#define begin_image_AvecEditionProgression \
Pbegin_image(BLOC(B_PROGRESSION_DES_BEGIN_END(Y,Ymin,dimY \
,UTILISER_LE_MODE_DIRECT_DE_PROGRESSION_DES_BEGIN_END \
,PTYPE_I \
); \
) \
)
#define end_image_AvecEditionProgression \
Pend_image(BLOC(E_PROGRESSION_DES_BEGIN_END;))
#define Pbegin_image_back(Bprogression) \
VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE; \
/* Verification introduite le 20170713121225... */ \
begin_colonne_back \
Bblock \
BLOC(Bprogression); \
\
begin_ligne \
Bblock
#define Pend_image_back(Eprogression) \
Eblock \
end_ligne \
\
BLOC(Eprogression); \
Eblock \
end_colonne_back
/* Introduit sous cette forme le 20170520092906 afin de faire que l'edition de la */
/* progression des {begin,end} ne soit disponible que pour les cas exceptionnels */
/* (via "_AvecEditionProgression") ou cela est justifie (par exemple : ombrage, */
/* accumulation,... Voir a ce propos 'v $xiii/di_album$FON _AvecEditionProgression'). */
#define begin_image_back \
Pbegin_image_back(BLOC(VIDE;))
#define end_image_back \
Pend_image_back(BLOC(VIDE;))
#define begin_image_back_AvecEditionProgression \
Pbegin_image_back(BLOC(B_PROGRESSION_DES_BEGIN_END(Y,Ymin,dimY \
,UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END \
,PTYPE_I \
); \
) \
)
#define end_image_back_AvecEditionProgression \
Pend_image_back(BLOC(E_PROGRESSION_DES_BEGIN_END;))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " T R A I T E M E N T " D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
#define Ptraite_image(Bprogression,Eprogression,sequence_de_traitement,Begin_colonne,End_colonne,Begin_ligne,End_ligne) \
VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE; \
/* Verification introduite le 20170713121225... */ \
Begin_colonne \
Bblock \
BLOC(Bprogression); \
\
Begin_ligne \
Bblock \
Test(TEST_MASQUE_ACTIF(X,Y,MASQUER_PARCOURS)) \
Bblock \
sequence_de_traitement; \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
End_ligne \
\
BLOC(Eprogression); \
Eblock \
End_colonne \
/* Introduits le 20170521081127... */
#define traite_image(mode,sequence_de_traitement,Begin_colonne,End_colonne,Begin_ligne,End_ligne) \
Ptraite_image(BLOC(VIDE;) \
,BLOC(VIDE;) \
,sequence_de_traitement \
,Begin_colonne,End_colonne \
,Begin_ligne,End_ligne \
)
#define traite_image_AvecEditionProgression(mode,sequence_de_traitement,Begin_colonne,End_colonne,Begin_ligne,End_ligne) \
Ptraite_image(BLOC(B_PROGRESSION_DES_BEGIN_END(Y,Ymin,dimY \
,mode \
,PTYPE_I \
); \
) \
,BLOC(E_PROGRESSION_DES_BEGIN_END;) \
,sequence_de_traitement \
,Begin_colonne,End_colonne \
,Begin_ligne,End_ligne \
)
#define traite_image_BH_GD(sequence_de_traitement) \
traite_image(ARGUMENT_INUTILE \
,BLOC(sequence_de_traitement) \
,begin_colonne,end_colonne \
,begin_ligne,end_ligne \
)
#define traite_image_BH_GD_AvecEditionProgression(sequence_de_traitement) \
traite_image_AvecEditionProgression(UTILISER_LE_MODE_DIRECT_DE_PROGRESSION_DES_BEGIN_END \
,BLOC(sequence_de_traitement) \
,begin_colonne,end_colonne \
,begin_ligne,end_ligne \
)
/* Traitement normal : */
/* */
/* de Bas (Y=Ymin) en Haut (Y=Ymax), */
/* */
/* et : */
/* */
/* de Gauche (X=Xmin) a Droite (X=Xmax). */
/* */
#define traite_image_HB_GD(sequence_de_traitement) \
traite_image(ARGUMENT_INUTILE \
,BLOC(sequence_de_traitement) \
,begin_colonne_back,end_colonne_back \
,begin_ligne,end_ligne \
)
#define traite_image_HB_GD_AvecEditionProgression(sequence_de_traitement) \
traite_image_AvecEditionProgression(UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END \
,BLOC(sequence_de_traitement) \
,begin_colonne_back,end_colonne_back \
,begin_ligne,end_ligne \
)
/* Traitement inverse : */
/* */
/* de Haut (Y=Ymax) en Bas (Y=Ymin), */
/* */
/* et : */
/* */
/* de Gauche (X=Xmin) a Droite (X=Xmax). */
/* */
#define traite_image_BH_DG(sequence_de_traitement) \
traite_image(ARGUMENT_INUTILE \
,BLOC(sequence_de_traitement) \
,begin_colonne,end_colonne \
,begin_ligne_back,end_ligne_back \
)
#define traite_image_BH_DG_AvecEditionProgression(sequence_de_traitement) \
traite_image_AvecEditionProgression(UTILISER_LE_MODE_DIRECT_DE_PROGRESSION_DES_BEGIN_END \
,BLOC(sequence_de_traitement) \
,begin_colonne,end_colonne \
,begin_ligne_back,end_ligne_back \
)
/* Traitement inverse : */
/* */
/* de Bas (Y=Ymin) en Haut (Y=Ymax), */
/* */
/* et : */
/* */
/* de Droite (X=Xmax) a Gauche (X=Xmin). */
/* */
#define traite_image_HB_DG(sequence_de_traitement) \
traite_image(ARGUMENT_INUTILE \
,BLOC(sequence_de_traitement) \
,begin_colonne_back,end_colonne_back \
,begin_ligne_back,end_ligne_back \
)
#define traite_image_HB_DG_AvecEditionProgression(sequence_de_traitement) \
traite_image_AvecEditionProgression(UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END \
,BLOC(sequence_de_traitement) \
,begin_colonne_back,end_colonne_back \
,begin_ligne_back,end_ligne_back \
)
/* Traitement inverse : */
/* */
/* de Haut (Y=Ymax) en Bas (Y=Ymin), */
/* */
/* et : */
/* */
/* de Droite (X=Xmax) a Gauche (X=Xmin). */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S S P E C I F I Q U E S D ' A L B U M ( ' Z ' P U I S ' Y ' P U I S ' X ' ) : */
/* */
/*************************************************************************************************************************************/
#define Pbegin_album(Bprogression) \
VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE; \
/* Verification introduite le 20170713121225... */ \
begin_fuite \
Bblock \
BLOC(Bprogression); \
\
begin_colonne \
Bblock \
begin_ligne \
Bblock
#define Pend_album(Eprogression) \
Eblock \
end_ligne \
Eblock \
end_colonne \
\
BLOC(Eprogression); \
Eblock \
end_fuite
/* Introduit sous cette forme le 20170520092906 afin de faire que l'edition de la */
/* progression des {begin,end} ne soit disponible que pour les cas exceptionnels */
/* (via "_AvecEditionProgression") ou cela est justifie (ombrage, accumulation,...). */
#define begin_album \
Pbegin_album(BLOC(VIDE;))
#define end_album \
Pend_album(BLOC(VIDE;))
#define begin_album_AvecEditionProgression \
Pbegin_album(BLOC(B_PROGRESSION_DES_BEGIN_END(Z,Zmin,dimZ \
,UTILISER_LE_MODE_DIRECT_DE_PROGRESSION_DES_BEGIN_END \
,PTYPE_A \
); \
) \
)
#define end_album_AvecEditionProgression \
Pend_album(BLOC(E_PROGRESSION_DES_BEGIN_END;))
#define Pbegin_album_back(Bprogression) \
VERIFICATIONS_DE_CONFLITS_POSSIBLES_AVEC__INDEXATION_SIMPLIFIEE; \
/* Verification introduite le 20170713121225... */ \
begin_fuite_back \
Bblock \
BLOC(Bprogression); \
\
begin_colonne \
Bblock \
begin_ligne \
Bblock
#define Pend_album_back(Eprogression) \
Eblock \
end_ligne \
Eblock \
end_colonne \
\
BLOC(Eprogression); \
Eblock \
end_fuite_back
/* Introduit sous cette forme le 20170520092906 afin de faire que l'edition de la */
/* progression des {begin,end} ne soit disponible que pour les cas exceptionnels */
/* (via "_AvecEditionProgression") ou cela est justifie (ombrage, accumulation,...). */
#define begin_album_back \
Pbegin_album_back(BLOC(VIDE;))
#define end_album_back \
Pend_album_back(BLOC(VIDE;))
#define begin_album_back_AvecEditionProgression \
Pbegin_album_back(BLOC(B_PROGRESSION_DES_BEGIN_END(Z,Zmin,dimZ \
,UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END \
,PTYPE_A \
); \
) \
)
#define end_album_back_AvecEditionProgression \
Pend_album_back(BLOC(E_PROGRESSION_DES_BEGIN_END;))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E P A R C O U R S D ' U N E N S E M B L E D E N I V E A U X D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
#define BoID(fonction_de_parcours,niveau_courant,niveau_minimal,niveau_maximal,pas_du_niveau) \
Bblock \
DEFV(Int,INIT(niveau_courant,UNDEF)); \
/* Niveau courant ; mais attention, celui-ci doit imperativement etre un */ \
/* 'Int' afin de ne pas poser de probleme pour la detection des fins de boucle */ \
/* avec les troncations qui sont faites par le compilateur sur le mode 'Char'/'CHAR' avant */ \
/* d'effectuer les tests de fin (ainsi, par exemple, 255+1=256 devient 0 apres troncation */ \
/* par un modulo 256)... */ \
fonction_de_parcours(niveau_courant,INTE(niveau_minimal),INTE(niveau_maximal),INTE(pas_du_niveau)) \
/* Parcours quelconque d'un ensemble de niveaux de couleurs. */
#define EBID(fin_de_fonction_de_parcours) \
fin_de_fonction_de_parcours \
Eblock \
/* Fin de parcours quelconque d'un ensemble de niveaux de couleurs. */
#define BoIn(niveau_courant,niveau_minimal,niveau_maximal,pas_du_niveau) \
BoID(DoIn,niveau_courant,niveau_minimal,niveau_maximal,pas_du_niveau) \
/* Parcours ascendant d'un ensemble de niveaux de couleurs. */
#define EBoI \
EBID(EDoI) \
/* Fin de parcours ascendant d'un ensemble de niveaux de couleurs. */
#define BoDe(niveau_courant,niveau_minimal,niveau_maximal,pas_du_niveau) \
BoID(DoDe,niveau_courant,niveau_minimal,niveau_maximal,pas_du_niveau) \
/* Parcours descendant d'un ensemble de niveaux de couleurs. */
#define EBoD \
EBID(EDoD) \
/* Fin de parcours descendant d'un ensemble de niveaux de couleurs. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R C O U R S E N S P I R A L E D ' U N E I M A G E : */
/* */
/* */
/* Nota : */
/* */
/* En general, on fera a la suite */
/* l'un de l'autre pour chaque point */
/* {x,y} de la spirale : */
/* */
/* SPIRALE_INITIALISATION; qui (re-)initialise eventuellement le bras courant, */
/* SPIRALE_DEPLACEMENT(x,y); qui deplace le point courant {x,y} sur la spirale, */
/* SPIRALE_PARCOURS; qui gere les changements d'orientation du bras de la spirale, */
/* */
/* ou en une seule fois ; */
/* */
/* SPIRALE_DEPLACEMENT_ET_PARCOURS(x,y,s); qui deplace le point courant {x,y} sur la spirale et gere les */
/* changements d'orientation du bras de la spirale avec de plus la */
/* possibilite de sauter 's' points. */
/* */
/* */
/* Parcours : */
/* */
/* En notant '0' le numero du premier */
/* point de la spirale (ou "centre"), le */
/* parcours de celle-ci se fait de la */
/* facon suivante : */
/* */
/* */
/* 4 -- 3 -- 2 */
/* | | . */
/* | | . */
/* 5 0 -- 1 . */
/* | | */
/* | | */
/* 6 -- 7 -- 8 -- 9 */
/* */
/* */
/* ATTENTION : */
/* */
/* Lorsqu'une telle spirale est utilisee */
/* pour generer des nombres aleatoires (ainsi */
/* que cela est fait dans '$xrq/nucleon.LB$I' */
/* par exemple) suivant le choix du centre de */
/* la spirale, le generateur sera independant */
/* du format de l'images (cas, par exemple, du */
/* choix du point [Xmin,Ymin,Zmin] comme centre */
/* de la spirale), ou pas (cas, par exemple, du */
/* choix du point [Xcentre,Ycentre,Zcentre] car */
/* en effet ces coordonnees varient avec le */
/* format de l'image contrairement au point */
/* origine [Xmin,Ymin,Zmin]...). */
/* */
/* */
/*************************************************************************************************************************************/
#define FACTEUR_DE_SPIRALE_DELTA_HORIZONTAL \
UN \
/* Facteur du pas de parcours horizontal initial d'une spirale, */
#define FACTEUR_DE_SPIRALE_DELTA_VERTICAL \
ZERO \
/* Facteur du pas de parcours vertical initial d'une spirale. */
#define SPIRALE_DELTA_HORIZONTAL_GENERAL(pas_X,pas_Y) \
SE12(pas_X,pas_Y) \
/* Pas de parcours horizontal initial d'une spirale, */
#define SPIRALE_DELTA_HORIZONTAL_GLOBAL \
MUL2(FACTEUR_DE_SPIRALE_DELTA_HORIZONTAL,SPIRALE_DELTA_HORIZONTAL_GENERAL(PasX,PasY)) \
/* Pas de parcours horizontal initial d'une spirale a utiliser dans le cas ennuyeux */ \
/* ou 'SPIRALE_DEFINITION' ou 'SPIRALE_DEFINITION_GENERALE(...)' seraient a utiliser */ \
/* au niveau des variables globales ; le compilateur refuse d'initialiser une variable */ \
/* globale ('spirale_delta_horizontal') avec une autre variable globale 'pasX')... */
#define SPIRALE_DELTA_VERTICAL_GENERAL(pas_X,pas_Y) \
SE22(pas_X,pas_Y) \
/* Pas de parcours vertical initial d'une spirale, */
#define SPIRALE_DELTA_VERTICAL_GLOBAL \
MUL2(FACTEUR_DE_SPIRALE_DELTA_VERTICAL,SPIRALE_DELTA_VERTICAL_GENERAL(PasX,PasY)) \
/* Pas de parcours vertical initial d'une spirale a utiliser dans le cas ennuyeux */ \
/* ou 'SPIRALE_DEFINITION' ou 'SPIRALE_DEFINITION_GENERALE(...)' seraient a utiliser */ \
/* au niveau des variables globales ; le compilateur refuse d'initialiser une variable */ \
/* globale ('spirale_delta_vertical') avec une autre variable globale 'pasX')... */
#define SPIRALE_DELTA_HORIZONTAL \
MUL2(SPIRALE_DEFINITION_____facteur_delta_horizontal,SPIRALE_DELTA_HORIZONTAL_GENERAL(pasX,pasY)) \
/* Pas de parcours horizontal initial d'une spirale, */
#define SPIRALE_DELTA_VERTICAL \
MUL2(SPIRALE_DEFINITION_____facteur_delta_vertical,SPIRALE_DELTA_VERTICAL_GENERAL(pasX,pasY)) \
/* Pas de parcours vertical initial d'une spirale. */
#define NOMBRE_DE_POINTS_SAUTES_SUR_LA_SPIRALE \
ZERO \
/* Cette constante definie le nombre de points que l'on saute lorsque l'on passe d'un point */ \
/* de la spirale au suivant. La valeur initiale fait que tous les points sont pris en compte */ \
/* et traites... */
#define PAS_DES_POINTS_SUR_LA_SPIRALE(Vnombre_de_points_sautes) \
SUCC(Vnombre_de_points_sautes) \
/* Pas des points sur la spirale (en general 1...). */
#define SPIRALE_PREMIER_BRAS \
UNITE \
/* Longueur du premier bras. */
#define SPIRALE_BRAS_INITIALISATION \
PRED(SPIRALE_PREMIER_BRAS) \
/* Pour forcer l'initialisation du nombre de points sur un bras. */
#define SPIRALE_DEFINITION \
SPIRALE_DEFINITION_GENERALE(SPIRALE_DELTA_HORIZONTAL,SPIRALE_DELTA_VERTICAL) \
/* Initialisation standard des spirales. On notera avec attention l'absence de point-virgule */ \
/* ";" apres 'SPIRALE_DEFINITION_GENERALE(...)' car, en effet, il s'agit la de donnees, et */ \
/* le risque serait alors de se retrouver avec plusieurs ";" contigus, ce qui est interdit */ \
/* par les compilateurs a l'interieur d'une zone de donnees (ceci se produirait si d'autres */ \
/* declarations de donnees suivaient par exemple 'SPIRALE_DEFINITION'). */
#define SPIRALE_DEFINITION_GENERALE(delta_horizontal,delta_vertical) \
/* Initialisation plus generale des spirales... */ \
DEFV(Int,INIT(spirale_delta_horizontal,delta_horizontal)); \
/* Pas horizontal de parcours de la spirale ; on va partir vers la droite, */ \
DEFV(Int,INIT(spirale_delta_vertical,delta_vertical)); \
/* Pas vertical de parcours de la spirale ; on va partir horizontalement. */ \
DEFV(Int,INIT(spirale_longueur_du_bras_courant,SPIRALE_PREMIER_BRAS)); \
/* Initialisation de la longueur du bras courant ; le premier bras */ \
/* a une longueur unite. */ \
DEFV(Int,INIT(spirale_nombre_de_points_a_traiter,SPIRALE_BRAS_INITIALISATION)); \
/* Nombre de points restant a traiter sur le bras courant ; on donne */ \
/* au nombre de points traites sur un bras une valeur forcant son */ \
/* initialisation... */ \
DEFV(Int,INIT(nombre_de_points_sur_la_spirale,ZERO)); \
/* Donne le nombre courant de points traites sur une spirale autour du */ \
/* point courant ; on l'initialise avec 'ZERO' au cas ou il serait utilise */ \
/* tel quel... */
#define SPIRALE_VALIDATION \
Bblock \
Test(IFNE(pasX,pasY)) \
Bblock \
PRINT_ERREUR("'pasX' et 'pasY' doivent etre egaux afin de parcourir correctement une spirale carree"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
/* ATTENTION : on ne peut mettre la sequence suivante : */ \
/* */ \
/* Test(IZEQ(PAS_DES_POINTS_SUR_LA_SPIRALE(Vnombre_de_points_sautes))) */ \
/* Bblock */ \
/* PRINT_ERREUR("le deplacement sur la spirale est impossible"); */ \
/* EGAL(Vnombre_de_points_sautes,NOMBRE_DE_POINTS_SAUTES_SUR_LA_SPIRALE); */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* d'une part parce qu'elle ne sert a rien (voir le 'Positive' qui sert a definir les */ \
/* variables du type 'Vnombre_de_points_sautes'), et d'autre part pour simplifier les */ \
/* choses, car toutes les spirales n'utilisent pas cette possibilite... */ \
Eblock
#define SPIRALE_INITIALISATION_DU_NOMBRE_DE_POINTS_A_SAUTER(Vnombre_de_points_sautes,Inombre_de_points_a_sauter) \
Bblock \
EGAL(Vnombre_de_points_sautes,Inombre_de_points_a_sauter); \
Eblock \
/* Initialisation du nombre de points a sauter sur la spirale. */
#define SPIRALE_REINITIALISATION_BRAS \
Bblock \
EGAL(spirale_longueur_du_bras_courant,SPIRALE_PREMIER_BRAS); \
/* Initialisation de la longueur du bras courant ; le premier bras */ \
/* a une longueur unite. */ \
EGAL(spirale_nombre_de_points_a_traiter,SPIRALE_BRAS_INITIALISATION); \
/* Et du nombre de points restant a traiter sur le bras courant ; on donne */ \
/* au nombre de points traites sur un bras une valeur forcant son */ \
/* initialisation... */ \
Eblock
#define SPIRALE_REINITIALISATION_DELTAS \
Bblock \
EGAL(spirale_delta_horizontal,SPIRALE_DELTA_HORIZONTAL); \
/* Pas horizontal de parcours de la spirale ; on va partir vers la droite, */ \
EGAL(spirale_delta_vertical,SPIRALE_DELTA_VERTICAL); \
/* Pas vertical de parcours de la spirale ; on va partir horizontalement. */ \
Eblock
#define SPIRALE_REINITIALISATION_BRAS_ET_DELTAS \
Bblock \
SPIRALE_REINITIALISATION_BRAS; \
/* Reinitialisation de la longueur du bras de la spirale. */ \
SPIRALE_REINITIALISATION_DELTAS; \
/* Reinitialisation des pas horizontal et vertical de parcours de la spirale. */ \
Eblock
#define SPIRALE_INITIALISATION \
Bblock \
Test(IFEQ(spirale_nombre_de_points_a_traiter,SPIRALE_BRAS_INITIALISATION)) \
Bblock \
EGAL(spirale_nombre_de_points_a_traiter,spirale_longueur_du_bras_courant); \
/* Le nombre de points a traiter sur le bras courant, est egal au */ \
/* nombre de points de ce bras. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define SPIRALE_REINITIALISATION_COMPTAGE \
Bblock \
CLIR(nombre_de_points_sur_la_spirale); \
/* Afin de compter les nombres de points de la spirale que l'on traite... */ \
Eblock
#define SPIRALE_DEPLACEMENT(X_point_spirale,Y_point_spirale) \
Bblock \
INCR(X_point_spirale,MUL2(SPIRALE_DEPLACEMENT_____amplitude_horizontale,spirale_delta_horizontal)); \
INCR(Y_point_spirale,MUL2(SPIRALE_DEPLACEMENT_____amplitude_verticale__,spirale_delta_vertical)); \
/* Et on deplace le point courant sur le bras courant. */ \
/* */ \
/* La possibilite de "dilater" la spirale a ete introduite le 20151109145531... */ \
Eblock
#define SPIRALE_PARCOURS \
Bblock \
DECR(spirale_nombre_de_points_a_traiter,I); \
/* Et on decompte les points traites sur le bras courant... */ \
Test(IFEQ(spirale_nombre_de_points_a_traiter,SPIRALE_BRAS_INITIALISATION)) \
Bblock \
Test(IFEQ(spirale_delta_horizontal,SPIRALE_DELTA_VERTICAL)) \
Bblock \
INCR(spirale_longueur_du_bras_courant,I); \
/* Un bras sur deux, on augmente la longueur de ceux-ci. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
SWAP(spirale_delta_horizontal,spirale_delta_vertical); \
\
EGAL(spirale_delta_horizontal \
,NEGA(MUL2(SPIRALE_PARCOURS_____sinus_de_l_angle_de_la_rotation,spirale_delta_horizontal)) \
); \
EGAL(spirale_delta_vertical \
,NEUT(MUL2(SPIRALE_PARCOURS_____sinus_de_l_angle_de_la_rotation,spirale_delta_vertical)) \
); \
/* On fait tourner le bras courant, ce qui revient a faire tourner de +/-(PI/2) */ \
/* le nombre complexe (spirale_delta_horizontal,spirale_delta_vertical). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define SPIRALE_DEPLACEMENT_ET_PARCOURS(X_point_spirale,Y_point_spirale,Vnombre_de_points_sautes) \
Bblock \
Repe(PAS_DES_POINTS_SUR_LA_SPIRALE(Vnombre_de_points_sautes)) \
/* Le nombre de deplacements a faire est egal au nombre de points a sauter plus un (le point */ \
/* d'arrivee...). */ \
Bblock \
SPIRALE_INITIALISATION; \
SPIRALE_DEPLACEMENT(X_point_spirale,Y_point_spirale); \
SPIRALE_PARCOURS; \
Eblock \
ERep \
Eblock
#define SPIRALE_COMPTAGE \
Bblock \
INCR(nombre_de_points_sur_la_spirale,I); \
/* Et on calcule le nombre de points que l'on a traite. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N D ' U N I N D E X D E S P I R A L E */
/* E N D E S C O O R D O N N E S ' X ' E T ' Y ' : */
/* */
/* */
/* Principe : */
/* */
/* */
/* diagonale */
/* des */
/* carres des nombres */
/* pairs */
/* */
/* * */
/* * */
/* 4 -- 3 -- 2 */
/* | * | . */
/* | * | . */
/* 5 0 -- 1 . */
/* | * | */
/* | *| */
/* 6 -- 7 -- 8 -- 9 */
/* * */
/* * */
/* */
/* diagonale */
/* des */
/* carres des nombres */
/* impairs */
/* */
/* */
/* La parite de la partie entiere du numero */
/* courant permet de savoir si l'on se situe */
/* dans le triangle inferieur (nombre pair) ou */
/* dans le triangle superieur (nombre impair). */
/* */
/* */
/*************************************************************************************************************************************/
#define SPIRALE_INDEX_RELATIF(index,saut) \
MUL2(PAS_DES_POINTS_SUR_LA_SPIRALE(saut),SOUS(index,PREMIER_POINT)) \
/* Calcul de l'index relatif au numero du premier point ; c'est lui qui sera appele 'n' par */ \
/* la suite... */
#define SPIRALE_RACINE_CARREE_ENTIERE(index,saut) \
INTE(RACX(FLOT(SPIRALE_INDEX_RELATIF(index,saut)))) \
/* Calcul de la racine carree "entiere" 'nr' de l'index 'n' de la spirale : */ \
/* */ \
/* __ */ \
/* / */ \
/* nr = E(\/ n ) */ \
/* */ \
/* Exemple : */ \
/* */ \
/* nr(3) = 1 */ \
/* nr(8) = 2 */ \
/* */
#define SPIRALE_CARRE_INFERIEUR(index,saut) \
EXP2(SPIRALE_RACINE_CARREE_ENTIERE(index,saut)) \
/* Calcul du carre ("entier") 'nr2' immediatement inferieur a l'index 'n' de la spirale : */ \
/* */ \
/* 2 */ \
/* nr2 = nr */ \
/* */
#define SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
MOIT(DOUP(SPIRALE_RACINE_CARREE_ENTIERE(index,saut))) \
/* Calcul de la moitie de la difference 'l' entre le carre qui suit immediatement 'nr2' et */ \
/* 'nr2' lui-meme, quantite qui permet de savoir si l'on trouve sur un bras vertical de */ \
/* spirale (lorsqu'on est inferieur a 'l'), ou bien sur un bras horizontal (lorsqu'on est */ \
/* superieur a 'l') : */ \
/* */ \
/* 2 2 */ \
/* (nr + 1) - nr */ \
/* l = ----------------- */ \
/* 2 */ \
/* */ \
/* 2 2 */ \
/* nr + 2.nr + 1 - nr */ \
/* l = ---------------------- */ \
/* 2 */ \
/* */ \
/* 2.nr + 1 */ \
/* l = ---------- */ \
/* 2 */ \
/* */
#define SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
SOUS(SPIRALE_INDEX_RELATIF(index,saut),SPIRALE_CARRE_INFERIEUR(index,saut)) \
/* Calcul de la "distance" 'd' mesuree sur la spirale de l'index 'n' au carre le precedant */ \
/* immediatement 'nr2' : */ \
/* */ \
/* d = n - nr2 */ \
/* */
#define SPIRALE_DISTANCE_AU_COIN_PRECEDENT(index,saut) \
COND(IFLE(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut),SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut)) \
,SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
,SOUS(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut),SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut)) \
) \
/* Calcul de la "distance" 'b' mesuree sur la spirale de l'index 'n' au "coin" le precedant */ \
/* immediatement : */ \
/* */ \
/* si d <= l : b = d ('n' est sur un bras vertical) */ \
/* si d > l : b = d - l ('n' est sur un bras horizontal) */ \
/* */
#define SPIRALE_COORDONNEES_DU_CARRE_INFERIEUR(index,saut) \
MOIT(COND(EST_PAIR(SPIRALE_CARRE_INFERIEUR(index,saut)) \
,NEUT(SPIRALE_RACINE_CARREE_ENTIERE(index,saut)) \
,TRMU(SPIRALE_RACINE_CARREE_ENTIERE(index,saut)) \
) \
) \
/* Caracterisation 'q' des coordonnees 'X' et 'Y' du carre 'nr2' precedant 'n' : */ \
/* */ \
/* si nr2 est pair : q = nr / 2 ('n' est dans le triangle inferieur) */ \
/* si nr2 est impair : q = (nr - 1) / 2 ('n' est dans le triangle superieur) */ \
/* */
#define SPIRALE_X_DU_CARRE_INFERIEUR(index,saut) \
COND(EST_PAIR(SPIRALE_CARRE_INFERIEUR(index,saut)) \
,NEGA(SPIRALE_COORDONNEES_DU_CARRE_INFERIEUR(index,saut)) \
,TRPU(SPIRALE_COORDONNEES_DU_CARRE_INFERIEUR(index,saut)) \
) \
/* Abscisse 'X0' du carre 'nr2' precedant 'n' : */ \
/* */ \
/* si nr2 est pair : X0 = -q ('n' est dans le triangle inferieur) */ \
/* si nr2 est impair : X0 = q + 1 ('n' est dans le triangle superieur) */ \
/* */
#define SPIRALE_Y_DU_CARRE_INFERIEUR(index,saut) \
COND(EST_PAIR(SPIRALE_CARRE_INFERIEUR(index,saut)) \
,NEUT(SPIRALE_COORDONNEES_DU_CARRE_INFERIEUR(index,saut)) \
,NEGA(SPIRALE_COORDONNEES_DU_CARRE_INFERIEUR(index,saut)) \
) \
/* Ordonnee 'Y0' du carre 'nr2' precedant 'n' : */ \
/* */ \
/* si nr2 est pair : Y0 = +q ('n' est dans le triangle inferieur) */ \
/* si nr2 est impair : Y0 = -q ('n' est dans le triangle superieur) */ \
/* */
#define Xcentre_SPIRALE \
k___Xmin
#define Ycentre_SPIRALE \
k___Ymin
/* Definition d'un centre arbitraire pour la spirale. */
/* */
/* ATTENTION, avant le 1995062000, il y avait ici : */
/* */
/* #define Xcentre_SPIRALE \ */
/* Xcentre */
/* #define Ycentre_SPIRALE \ */
/* Ycentre */
/* */
/* Malheureusement, depuis l'introduction des fonctions 'FiSPIRALE_X(...)' et */
/* 'FiSPIRALE_Y(...)' introduites dans '$xig/fonct$vv$FON', ces definitions ne */
/* sont plus acceptables car, en effet, elles demandent {Xmin,Xmax,Ymin,Ymax}, ce */
/* que certains programmes (par exemple, ceux de '$xcp') ne connaissent pas. D'ou */
/* cette nouvelle definition "constante"... */
#define SPIRALE_X(index,saut) \
COOA(COND(EST_PAIR(SPIRALE_CARRE_INFERIEUR(index,saut)) \
,COND(IFLE(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
,NEUT(SPIRALE_X_DU_CARRE_INFERIEUR(index,saut)) \
,ADD2(SPIRALE_X_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_DISTANCE_AU_COIN_PRECEDENT(index,saut) \
) \
) \
,COND(IFLE(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
,NEUT(SPIRALE_X_DU_CARRE_INFERIEUR(index,saut)) \
,SOUS(SPIRALE_X_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_DISTANCE_AU_COIN_PRECEDENT(index,saut) \
) \
) \
) \
,Xcentre_SPIRALE \
) \
/* Abscisse 'X' de 'n'... */
#define SPIRALE_Y(index,saut) \
COOA(COND(EST_PAIR(SPIRALE_CARRE_INFERIEUR(index,saut)) \
,COND(IFLE(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
,SOUS(SPIRALE_Y_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_DISTANCE_AU_COIN_PRECEDENT(index,saut) \
) \
,SOUS(SPIRALE_Y_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
) \
,COND(IFLE(SPIRALE_DISTANCE_AU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
,ADD2(SPIRALE_Y_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_DISTANCE_AU_COIN_PRECEDENT(index,saut) \
) \
,ADD2(SPIRALE_Y_DU_CARRE_INFERIEUR(index,saut) \
,SPIRALE_CARACTERISATION_DU_BRAS_COURANT(index,saut) \
) \
) \
) \
,Ycentre_SPIRALE \
) \
/* Ordonnee 'Y' de 'n'.... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R C O U R S C I R C U L A I R E D ' U N E S P I R A L E C A R R E E : */
/* */
/*************************************************************************************************************************************/
#define SPIRALE_CIRCULAIRE_VALIDATION(Vnombre_de_points_sautes) \
Bblock \
Test(IFNE(pasX,pasY)) \
Bblock \
PRINT_ERREUR("'pasX' et 'pasY' doivent etre egaux afin de parcourir correctement une spirale circulaire"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Test(IFNE(Vnombre_de_points_sautes,NOMBRE_DE_POINTS_SAUTES_SUR_LA_SPIRALE)) \
Bblock \
PRINT_ERREUR("sur une spirale circulaire, on ne peut sauter des points, ce parametre est donc ignore"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define INITIALISER_UNE_SPIRALE_CIRCULAIRE \
VRAI
#define NE_PAS_INITIALISER_UNE_SPIRALE_CIRCULAIRE \
NOTL(INITIALISER_UNE_SPIRALE_CIRCULAIRE)
#define DESINITIALISER_UNE_SPIRALE_CIRCULAIRE \
VRAI
#define NE_PAS_DESINITIALISER_UNE_SPIRALE_CIRCULAIRE \
NOTL(DESINITIALISER_UNE_SPIRALE_CIRCULAIRE)
#define SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS(X_spirale,Y_spirale,X_centre,Y_centre,numero,XY_max,initialiser,desinitialiser) \
Bblock \
DEFV(pointI_2D,point_de_numero_cherche_relatif_au_centre); \
CALS(Fparcours_circulaire_d_une_spirale_carree(ADRESSE(point_de_numero_cherche_relatif_au_centre) \
,numero \
,XY_max \
,initialiser \
,desinitialiser \
) \
); \
/* Definition d'un point de manoeuvre donnant le point courant de la spirale relativement */ \
/* au centre... */ \
EGAL(X_spirale \
,ADD2(X_centre \
,MUL2(SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS_____amplitude_horizontale \
,COXR(ASD1(point_de_numero_cherche_relatif_au_centre,x)) \
) \
) \
); \
EGAL(Y_spirale \
,ADD2(Y_centre \
,MUL2(SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS_____amplitude_verticale__ \
,COYR(ASD1(point_de_numero_cherche_relatif_au_centre,y)) \
) \
) \
); \
/* Et enfin generation des coordonnees absolues du point courant... */ \
/* */ \
/* La possibilite de "dilater" la spirale a ete introduite le 20151109145531... */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S F O N C T I O N S D ' E D I T I O N : */
/* */
/*************************************************************************************************************************************/
#define PRINT_ABSCISSE \
Bblock \
CAL3(Prme2("X=%0*d\n",NOMBRE_DE_CHIFFRES_DECIMAUX(dimX),X)); \
/* Edition de l'abscisse 'X' courante. */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210182839. */ \
Eblock
#define PRINT_ORDONNEE \
Bblock \
CAL3(Prme2("Y=%0*d\n",NOMBRE_DE_CHIFFRES_DECIMAUX(dimY),Y)); \
/* Edition de l'ordonnee 'Y' courante. */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210182839. */ \
Eblock
#define PRINT_COLONNE \
Bblock \
Test(IFEQ(Y,Ymin)) \
Bblock \
PRINT_ABSCISSE; \
/* Edition de l'abscisse 'X' courante en debut de chaque colonne */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define PRINT_LIGNE \
Bblock \
Test(IFEQ(X,Xmin)) \
Bblock \
PRINT_ORDONNEE; \
/* Edition de l'ordonnee 'Y' courante en debut de chaque ligne. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define PRINT_CHARGE(pas) \
Bblock \
Test(IFET(IFEQ(Y,Ymin),IFEQ(X,Xmin))) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
/* Par prudence... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFET(IZEQ(REST(COYR(Y),pas)),IFEQ(X,Xmin))) \
Bblock \
Repe(DIVZ(COYR(Y),pas)) \
Bblock \
CAL3(Prme1(FORMAT_CHAR,K_ETOILE)); \
/* Au debut de chaque ligne, on edite une suite d'etoiles montrant le travail deja */ \
/* effectue et dont le nombre est proportionnel a 'Y'. */ \
Eblock \
ERep \
\
Repe(DIVZ(SOUS(dimY,COYR(Y)),pas)) \
Bblock \
CAL3(Prme1(FORMAT_CHAR,K_POINT)); \
/* Au bout de chaque ligne, on edite une suite de points montrant le travail encore a */ \
/* effectuer, et dont le nombre est proportionnel a 'dimY-Y'. */ \
Eblock \
ERep \
\
CALS(Fsauts_de_lignes(UN)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Cette macro permet par une edition periodique de petites etoiles de se situer par */ \
/* rapport a la masse totale du travail a effectuer... Elle ne fonctionne bien qu'avec */ \
/* la macro 'begin_image'/'end_image' de parcours des images. */
#define INHIBER____begin_end_____editer_la_progression \
BSaveModifyVariable(Logical \
,begin_end_____editer_la_progression \
,FAUX \
);
#define RESTAURER__begin_end_____editer_la_progression \
ESaveModifyVariable(Logical \
,begin_end_____editer_la_progression \
);
/* Introduit le 20170519145548 pour, par exemple, bloquer a priori l'edition de la */
/* progression dans des fonctions qui ne le "meritent" pas. */
#define UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END \
VRAI
#define UTILISER_LE_MODE_DIRECT_DE_PROGRESSION_DES_BEGIN_END \
NOTL(UTILISER_LE_MODE_BACK___DE_PROGRESSION_DES_BEGIN_END)
/* Modes introduits le 20170402102304... */
#define PTYPE_A \
"album"
#define PTYPE_I \
"image"
/* Modes introduits le 20170402102304... */
#define B_PROGRESSION_DES_BEGIN_END(coordonnee,coordonnee_minimale,dimension_de_la_coordonnee,utiliser_le_mode_back,type) \
/* Le parametre 'mode_de_PROGRESSION_DES_BEGIN_END' a ete introduit le 20170402102304... */ \
/* */ \
/* Le parametre 'type' a ete introduit le 20170519154357... */ \
Bblock \
Test(IL_FAUT(begin_end_____editer_la_progression)) \
Bblock \
Test(IZEQ(begin_end_____compteur_d_imbrications)) \
Bblock \
CALS(Fprogression_des_begin_end(INTE(coordonnee) \
,INTE(coordonnee_minimale) \
,INTE(dimension_de_la_coordonnee) \
,begin_end_____pas_d_edition_de_la_progression \
,utiliser_le_mode_back \
,Gvar_sHOTE \
,Gvar_HOST \
,identifiant_de_branches_paralleles \
,nom_de_la_commande_courante \
,FICHIER_COURANT_RELATIF \
,NomDeLaFonctionCourante \
,LIGNE_COURANTE \
,type \
) \
); \
/* ATTENTION : c'est bien 'nom_de_la_commande_courante' et non 'NOM_DE_LA_COMMANDE_COURANTE' */ \
/* qui doit figurer ci-dessus et ce a cause du type 'CHAR' attendu pour cet argument... */ \
/* */ \
/* L'argument 'type' a ete introduit le 20170519154357... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCR(begin_end_____compteur_d_imbrications,I); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition eventuelle de la progression d'un parcours d'image... */
#define E_PROGRESSION_DES_BEGIN_END \
Bblock \
Test(IL_FAUT(begin_end_____editer_la_progression)) \
Bblock \
DECR(begin_end_____compteur_d_imbrications,I); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Fin de l'edition eventuelle de la progression d'un parcours d'image. Ceci a ete */ \
/* introduit le 20170405114853 (voir 'v $xig/fonct$vv$FON 20170405114345'). */