/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E L A G E N E R A T I O N D E S I M A G E S : */
/* */
/* */
/* Nota important : */
/* */
/* Le numero des images, via la procedure */
/* 'NUMERO_DE_L_IMAGE(...)' ne peut etre */
/* parametre car, en effet, il est donne */
/* directement par 'numero_de_la_periode_courante', */
/* qui lui-meme est fixe par un 'Komp(...)'. */
/* Le numero de la premiere image generee est */
/* donc egal a 'PREMIERE_ITERATION_D_UN_Komp', */
/* c'est-a-dire 1, et ne peut donc etre */
/* modifie... */
/* */
/* */
/* Author of '$xrq/nucleon.LN$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 1991??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N V O L U T I O N D ' U N E C O M P O S A N T E A F I N D E L I M I T E R */
/* L ' A L I A S I N G S U R L E S I M A G E S F I X E S : */
/* */
/*************************************************************************************************************************************/
#define CONVOLUER_LE_NOIR \
FAUX
DEFV(Local,DEFV(Logical,INIT(convoluer_le_NOIR,CONVOLUER_LE_NOIR)));
/* Indicateur disant si le niveau 'NOIR' est "traitable" lors de la convolution, ce qui */
/* fixe donc la valeur qui lui est associee dans 'niveaux_a_traiter_lors_d_une_convolution'. */
#define CONVOLUTION_A_NOYAU_VARIABLE \
FAUX
DEFV(Local,DEFV(Logical,INIT(convolution_a_noyau_variable,CONVOLUTION_A_NOYAU_VARIABLE)));
/* Indicateur disant si le noyau de convolution est "statique" ('FAUX') ou bien variable */
/* ('VRAI') et calcule a partir du complement de la composante courante. Dans ce cas, il */
/* semble preferable d'avoir : */
/* */
/* convoluer_le_NOIR = VRAI. */
/* */
DEFV(Local,DEFV(Logical,DTb1(niveaux_a_traiter_lors_d_une_convolution,COULEURS)));
/* Definit les niveaux sur lesquels on doit faire la convolution par 'Pconvolution()'. */
DEFV(Local,DEFV(Logical,DTb1(niveaux_cumulables_lors_d_une_convolution,COULEURS)));
/* Definit les niveaux cumulables lors du calcul de 'Pconvolution_____cumul_courant'. */
#define FACTEUR_MULTIPLICATIF_DE_CONVOLUTION \
FU
DEFV(Local,DEFV(Float,INIT(facteur_multiplicatif_de_convolution
,FACTEUR_MULTIPLICATIF_DE_CONVOLUTION
)
)
);
/* Facteur multiplicatif du produit de convolution en chaque point {X,Y}. */
#define FACTEUR_DU_NOMBRE_DE_POINTS_DU_NOYAU_DE_CONVOLUTION \
GRO1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(facteur_du_nombre_de_points_du_noyau_de_convolution
,FACTEUR_DU_NOMBRE_DE_POINTS_DU_NOYAU_DE_CONVOLUTION
)
)
);
/* Facteur multiplicatif destine a calculer le nombre de points des noyaux de convolution */
/* variables a partir de l'image 'GENERATEUR_DE_NOYAUX_VARIABLES'. */
#define DIMENSION_DU_NOYAU_DE_CONVOLUTION(demi_longueur) \
EXP2(DOUP(demi_longueur))
#define ABSENCE_DE_CONVOLUTION \
DIMENSION_DU_NOYAU_DE_CONVOLUTION(ZERO)
#TestADef NOMBRE_DE_POINTS_DU_NOYAU_DE_CONVOLUTION \
DIMENSION_DU_NOYAU_DE_CONVOLUTION(UN)
#define NOMBRE_MAXIMAL_DE_POINTS_DU_NOYAU_DE_CONVOLUTION \
TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION
DEFV(Local,DEFV(Positive,INIT(nombre_de_points_du_noyau_de_convolution,NOMBRE_DE_POINTS_DU_NOYAU_DE_CONVOLUTION)));
/* Nombre de points du noyau, une valeur unite signifiant l'absence de convolution... */
DEFV(Local,DEFV(Float,DTb1(noyau_de_convolution,NOMBRE_MAXIMAL_DE_POINTS_DU_NOYAU_DE_CONVOLUTION)));
/* Noyau de la convolution, */
DEFV(Local,DEFV(Logical,DTb1(inhibition_du_noyau_de_convolution,NOMBRE_MAXIMAL_DE_POINTS_DU_NOYAU_DE_CONVOLUTION)));
/* Et sa liste d'activite. */
#define ELEMENT_COURANT_DU_NOYAU_DE_CONVOLUTION(numero,valeur) \
Bblock \
EGAL(ITb1(noyau_de_convolution,INDX(numero,PREMIER_POINT)),valeur); \
EGAL(ITb1(inhibition_du_noyau_de_convolution,INDX(numero,PREMIER_POINT)),ACTIF); \
Eblock \
/* Initialisation de l'element courant du noyau de convolution... */
#define PRISE_EN_COMPTE_DU_POINT_CENTRAL \
FU
#define MOYENNAGE_DES_AUTRES_POINTS \
FDU
/* Valeurs a donner aux elements du noyau de convolution pour anti-aliaser... */
#define INITIALISATION_DU_NOYAU_DE_CONVOLUTION \
Bblock \
Test(IFGT(nombre_de_points_du_noyau_de_convolution,ABSENCE_DE_CONVOLUTION)) \
Bblock \
DEFV(Int,INIT(index_du_noyau_de_convolution,UNDEF)); \
/* Index d'initialisation du noyau. */ \
BoIn(niveau_courant_du_noyau_de_convolution,NOIR,BLANC,PAS_COULEURS) \
Bblock \
EGAL(ITb1(niveaux_a_traiter_lors_d_une_convolution,INDX(niveau_courant_du_noyau_de_convolution,NOIR)) \
,COND(IFOU(IFNE(niveau_courant_du_noyau_de_convolution,NOIR) \
,IFET(IFEQ(niveau_courant_du_noyau_de_convolution,NOIR) \
,IL_FAUT(convoluer_le_NOIR) \
) \
) \
,VRAI \
,FAUX \
) \
); \
EGAL(ITb1(niveaux_cumulables_lors_d_une_convolution,INDX(niveau_courant_du_noyau_de_convolution,NOIR)) \
,VRAI \
); \
/* Initialisation telle que tous les niveaux soient a la fois "traitables" (sauf suivant */ \
/* l'indicateur 'convoluer_le_NOIR', le 'NOIR') et "cumulables". */ \
Eblock \
EBoI \
DoIn(index_du_noyau_de_convolution \
,PREMIER_POINT \
,LSTX(PREMIER_POINT \
,MIN2(NOMBRE_MAXIMAL_DE_POINTS_DU_NOYAU_DE_CONVOLUTION \
,MAX2(ABSENCE_DE_CONVOLUTION \
,nombre_de_points_du_noyau_de_convolution \
) \
) \
) \
,I \
) \
Bblock \
ELEMENT_COURANT_DU_NOYAU_DE_CONVOLUTION(index_du_noyau_de_convolution \
,COND(IFEQ(index_du_noyau_de_convolution,PREMIER_POINT) \
,PRISE_EN_COMPTE_DU_POINT_CENTRAL \
,MOYENNAGE_DES_AUTRES_POINTS \
) \
); \
/* Initialisation du noyau de convolution. */ \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Initialisation du noyau de convolution. */
#define CONVOLUTION \
ImageA4 \
/* Definition de l'image contenant le resultat d'une convolution. */
#define GENERATEUR_DE_NOYAUX_VARIABLES \
ImageA5 \
/* Definition de l'image contenant le generateur de noyaux variables de convolution. */
#define CONVOLUTION_D_UNE_COMPOSANTE(composante) \
Bblock \
Test(IFGT(nombre_de_points_du_noyau_de_convolution,ABSENCE_DE_CONVOLUTION)) \
Bblock \
Test(IL_NE_FAUT_PAS(convoluer_le_NOIR)) \
Bblock \
CALi(Inoir(CONVOLUTION)); \
/* En effet, lorsque le 'NOIR' ne doit pas etre convolue, l'appel a 'Iconvolution(...)' ne */ \
/* met pas a jour tous les points de l'image 'CONVOLUTION', auquel cas, on recupere ainsi */ \
/* des morceaux d'autres composantes, d'ou cette initialisation... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(convolution_a_noyau_variable)) \
Bblock \
DEFV(genere_p,INIT(seuil_d_inhibition_du_noyau,GRIS_4)); \
BDEFV(image,image_definissant_la_valeur_du_noyau); \
BDEFV(image,image_inhibant_la_valeur_du_noyau); \
/* Pour definir la valeur du noyau... */ \
\
CALS(Iblanc(image_definissant_la_valeur_du_noyau)); \
CALS(Iinitialisation(image_inhibant_la_valeur_du_noyau,seuil_d_inhibition_du_noyau)); \
/* De facon a definir un noyau carre de valeur (1,1,1,...). */ \
\
CALS(Icomplementation(GENERATEUR_DE_NOYAUX_VARIABLES,composante)); \
/* L'image generateur du noyau de convolution est en fait le complement de la composante */ \
/* courante... */ \
CALS(Iconvolution_variable(CONVOLUTION \
,facteur_multiplicatif_de_convolution \
,composante \
,niveaux_a_traiter_lors_d_une_convolution \
,niveaux_cumulables_lors_d_une_convolution \
,facteur_du_nombre_de_points_du_noyau_de_convolution \
,GENERATEUR_DE_NOYAUX_VARIABLES \
,image_definissant_la_valeur_du_noyau \
,image_inhibant_la_valeur_du_noyau \
,seuil_d_inhibition_du_noyau \
) \
); \
/* Convolution de l'image point a point (sauf peut-etre ceux qui sont 'NOIR's, voir a ce */ \
/* propos 'convoluer_le_NOIR') en fonction d'un image 'GENERATEUR_DE_NOYAUX_VARIABLES'. */ \
\
EDEFV(image,image_inhibant_la_valeur_du_noyau); \
EDEFV(image,image_definissant_la_valeur_du_noyau); \
/* Pour definir la valeur du noyau... */ \
Eblock \
ATes \
Bblock \
CALS(Iconvolution(CONVOLUTION \
,facteur_multiplicatif_de_convolution \
,composante \
,niveaux_a_traiter_lors_d_une_convolution \
,niveaux_cumulables_lors_d_une_convolution \
,nombre_de_points_du_noyau_de_convolution \
,noyau_de_convolution \
,inhibition_du_noyau_de_convolution \
) \
); \
/* Convolution de l'image point a point (sauf peut-etre ceux qui sont 'NOIR's, voir a ce */ \
/* propos 'convoluer_le_NOIR') a l'aide d'un noyau "statique"... */ \
Eblock \
ETes \
\
CALS(Imove(composante,CONVOLUTION)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Convolution d'une composante... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S T R A I N E E S : */
/* */
/*************************************************************************************************************************************/
#include xrv/champs_5.LN.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D U N I V E A U D E N O I R : */
/* */
/*************************************************************************************************************************************/
#define NIVEAU_DE_NOIR_REMONTE \
NOIR
DEFV(Local,DEFV(genere_p,INIT(niveau_de_NOIR_remonte,NIVEAU_DE_NOIR_REMONTE)));
/* Niveau de NOIR de chacune des composantes ; on notera que bien entendu, cette remontee */
/* eventuelle du niveau de NOIR ne peut se faire qu'apres toutes les operations de calcul */
/* et de gestion des trainees... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
#define MEMORISER_LES_IMAGES \
VRAI
DEFV(Local,DEFV(Logical,INIT(memoriser_les_images,MEMORISER_LES_IMAGES)));
/* Indicateur disant si les images doivent etre generees. Cet indicateur est valable aussi */
/* pour le champ global... */
DEFV(Local,DEFV(CHAR,INIT(POINTERc(nom_imageR),NOM_PIPE_Local)));
/* Nom de la sequence a generer... */
#define NUMERO_DE_L_IMAGE(numero_de_l_image) \
ChaineNumero(numero_de_l_image,NOMBRE_DE_CHIFFRES) \
/* Numero caracteristique d'une image. */ \
/* */ \
/* Le 20080602135239 fut introduit 'ChaineNumero(...)' afin de pouvoir parametrer */ \
/* aisement le nombre de chiffres des numeros... */
#if ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
# define SEPARATEUR_DU_NUMERO \
cSEPARATEUR_DES_COMPOSANTES_D_UN_NOM \
/* Pour mettre avant le numero d'une image. Le 20070423140325, 'C_POINT' fut remplace */ \
/* par 'cSEPARATEUR_DES_COMPOSANTES_D_UN_NOM'. */
# define METTRE_LE_POSTFIXE_EN_QUEUE_DES_NOMS_DES_IMAGES \
FAUX
DEFV(Local,DEFV(Logical,INIT(mettre_le_postfixe_en_queue_des_noms_des_images,METTRE_LE_POSTFIXE_EN_QUEUE_DES_NOMS_DES_IMAGES)));
/* Indicateur disant si le postfixe ('c_ROUGE', 'c_VERTE' et 'c_BLEUE') doit etre mis en */
/* queue des noms des images ('VRAI'), ou bien au milieu ('FAUX') ; cette derniere option */
/* correspond au fonctionnement "ancien", et est introduite afin d'assurer la compatibilite */
/* avec ce qui a deja ete genere... */
# define NOM_DE_L_IMAGE(nom_de_l_image,nom_de_la_composante,numero_de_l_image) \
COND(IL_FAUT(mettre_le_postfixe_en_queue_des_noms_des_images) \
,chain_Aconcaten4_sauf_nom_pipe(nom_de_l_image \
,SEPARATEUR_DU_NUMERO \
,NUMERO_DE_L_IMAGE(numero_de_l_image) \
,nom_de_la_composante \
) \
,chain_Aconcaten4_sauf_nom_pipe(nom_de_l_image \
,nom_de_la_composante \
,SEPARATEUR_DU_NUMERO \
,NUMERO_DE_L_IMAGE(numero_de_l_image) \
) \
) \
/* Nom d'une composante d'une image de numero donne permettant d'assurer la compatibilite */ \
/* avec ce qui existe deja... */
#Aif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#Eif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#if (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
# define NOM_DE_L_IMAGE(nom_de_l_image,nom_de_la_composante,numero_de_l_image) \
chain_Aconcaten3_sauf_nom_pipe(nom_de_l_image \
,NUMERO_DE_L_IMAGE(numero_de_l_image) \
,nom_de_la_composante \
) \
/* Nom d'une composante d'une image de numero donne dans le style "nouveau"... */
#Aif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
#Eif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
#define TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE \
DEUX \
/* Lorsqu'il n'y a pas suffisamment d'espace-disque de libre, on attend un certain temps */ \
/* avant de renouveler le test... */
#define TEST_D_UNE_COMPOSANTE(nom_de_l_image) \
Bblock \
Test(IL_FAUT(memoriser_les_images)) \
Bblock \
Test(IFGT(nombre_d_images_generees,nombre_d_images_simultanees_moins_une)) \
/* Nota : on fait un 'IFGT(...)' afin d'assurer la coherence avec les 'COND(...)' qui sont */ \
/* dans les appels de 'TEST_D_UNE_COMPOSANTE(...)'. */ \
Bblock \
Tant(PAS_D_ERREUR(Itest_image(nom_de_l_image))) \
Bblock \
DODO(TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE); \
/* Si la composante existe, on attend qu'elle n'existe plus, ce qui fera de la place sur */ \
/* les disques pour les nouvelles images... */ \
Eblock \
ETan \
Eblock \
ATes \
Bblock \
/* Au debut de la simulation, ce test n'est pas effectue... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Test de l'existence d'une composante avec attente si elle existe... */
#ifdef BUG_SYSTEME_COMMANDE_SYSTEM_1
# define GENERATION_D_UNE_COMPOSANTE(nom_de_l_image,image) \
Bblock \
Test(IL_FAUT(memoriser_les_images)) \
Bblock \
Tant(IL_Y_A_ERREUR(Iupdate_image(nom_de_l_image,image))) \
Bblock \
DODO(TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE); \
/* S'il y a erreur, on considere que c'est parce qu'il n'y a pas assez de place, et dans */ \
/* dans ces conditions, on attend un peu avant de renouveler le test... */ \
Eblock \
ETan \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Generation d'une composante de nom donne... */
#Aifdef BUG_SYSTEME_COMMANDE_SYSTEM_1
# if ( (defined(SYSTEME_SG4D20G_IRIX)) \
|| (defined(SYSTEME_SG4D25TG_IRIX)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX)) \
|| (defined(SYSTEME_SG4D35TG_IRIX)) \
|| (defined(SYSTEME_SG4D85GT_IRIX)) \
|| (defined(SYSTEME_SGIND308_IRIX)) \
|| (defined(SYSTEME_SGIND324_IRIX)) \
|| (defined(SYSTEME_SGIND3GA_IRIX)) \
|| (defined(SYSTEME_SGIND408_IRIX)) \
|| (defined(SYSTEME_SGIND424_IRIX)) \
|| (defined(SYSTEME_SGIND4GA_IRIX)) \
|| (defined(SYSTEME_SGIND508_IRIX)) \
|| (defined(SYSTEME_SGIND524_IRIX)) \
|| (defined(SYSTEME_SGIND5GA_IRIX)) \
|| (defined(SYSTEME_SGIND808_IRIX)) \
|| (defined(SYSTEME_SGIND824_IRIX)) \
|| (defined(SYSTEME_SGIND8GA_IRIX)) \
|| (defined(SYSTEME_SGINDA08_IRIX)) \
|| (defined(SYSTEME_SGINDA24_IRIX)) \
|| (defined(SYSTEME_SGINDAGA_IRIX)) \
|| (defined(SYSTEME_SGO200A1_IRIX)) \
|| (defined(SYSTEME_SGO200A2_IRIX)) \
|| (defined(SYSTEME_SGO200A4_IRIX)) \
|| (defined(SYSTEME_SGO25224_IRIX)) \
|| (defined(SYSTEME_SGO252VA_IRIX)) \
|| (defined(SYSTEME_SGO252VN_IRIX)) \
|| (defined(SYSTEME_SGPCM801_IRIX)) \
|| (defined(SYSTEME_SGPCMA01_IRIX)) \
)
# define NOMBRE_D_IMAGES_DEVANT_ETRE_LIBRES \
HUIT \
/* Nombre d'images qui doivent etre libres pour poursuivre la simulation... */
# define GENERATION_D_UNE_COMPOSANTE(nom_de_l_image,image) \
Bblock \
Test(IL_FAUT(memoriser_les_images)) \
Bblock \
CALS(Itest_espace_disque_libre(NOMBRE_D_IMAGES_DEVANT_ETRE_LIBRES)); \
CALi(Iupdate_image(nom_de_l_image,image)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Generation d'une composante de nom donne... */
# Aif ( (defined(SYSTEME_SG4D20G_IRIX)) \
|| (defined(SYSTEME_SG4D25TG_IRIX)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX)) \
|| (defined(SYSTEME_SG4D35TG_IRIX)) \
|| (defined(SYSTEME_SG4D85GT_IRIX)) \
|| (defined(SYSTEME_SGIND308_IRIX)) \
|| (defined(SYSTEME_SGIND324_IRIX)) \
|| (defined(SYSTEME_SGIND3GA_IRIX)) \
|| (defined(SYSTEME_SGIND408_IRIX)) \
|| (defined(SYSTEME_SGIND424_IRIX)) \
|| (defined(SYSTEME_SGIND4GA_IRIX)) \
|| (defined(SYSTEME_SGIND508_IRIX)) \
|| (defined(SYSTEME_SGIND524_IRIX)) \
|| (defined(SYSTEME_SGIND5GA_IRIX)) \
|| (defined(SYSTEME_SGIND808_IRIX)) \
|| (defined(SYSTEME_SGIND824_IRIX)) \
|| (defined(SYSTEME_SGIND8GA_IRIX)) \
|| (defined(SYSTEME_SGINDA08_IRIX)) \
|| (defined(SYSTEME_SGINDA24_IRIX)) \
|| (defined(SYSTEME_SGINDAGA_IRIX)) \
|| (defined(SYSTEME_SGO200A1_IRIX)) \
|| (defined(SYSTEME_SGO200A2_IRIX)) \
|| (defined(SYSTEME_SGO200A4_IRIX)) \
|| (defined(SYSTEME_SGO25224_IRIX)) \
|| (defined(SYSTEME_SGO252VA_IRIX)) \
|| (defined(SYSTEME_SGO252VN_IRIX)) \
|| (defined(SYSTEME_SGPCM801_IRIX)) \
|| (defined(SYSTEME_SGPCMA01_IRIX)) \
)
# define GENERATION_D_UNE_COMPOSANTE(nom_de_l_image,image) \
Bblock \
Test(IL_FAUT(memoriser_les_images)) \
Bblock \
CALi(Iupdate_image(nom_de_l_image,image)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Generation d'une composante de nom donne... */
# Eif ( (defined(SYSTEME_SG4D20G_IRIX)) \
|| (defined(SYSTEME_SG4D25TG_IRIX)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX)) \
|| (defined(SYSTEME_SG4D35TG_IRIX)) \
|| (defined(SYSTEME_SG4D85GT_IRIX)) \
|| (defined(SYSTEME_SGIND308_IRIX)) \
|| (defined(SYSTEME_SGIND324_IRIX)) \
|| (defined(SYSTEME_SGIND3GA_IRIX)) \
|| (defined(SYSTEME_SGIND408_IRIX)) \
|| (defined(SYSTEME_SGIND424_IRIX)) \
|| (defined(SYSTEME_SGIND4GA_IRIX)) \
|| (defined(SYSTEME_SGIND508_IRIX)) \
|| (defined(SYSTEME_SGIND524_IRIX)) \
|| (defined(SYSTEME_SGIND5GA_IRIX)) \
|| (defined(SYSTEME_SGIND808_IRIX)) \
|| (defined(SYSTEME_SGIND824_IRIX)) \
|| (defined(SYSTEME_SGIND8GA_IRIX)) \
|| (defined(SYSTEME_SGINDA08_IRIX)) \
|| (defined(SYSTEME_SGINDA24_IRIX)) \
|| (defined(SYSTEME_SGINDAGA_IRIX)) \
|| (defined(SYSTEME_SGO200A1_IRIX)) \
|| (defined(SYSTEME_SGO200A2_IRIX)) \
|| (defined(SYSTEME_SGO200A4_IRIX)) \
|| (defined(SYSTEME_SGO25224_IRIX)) \
|| (defined(SYSTEME_SGO252VA_IRIX)) \
|| (defined(SYSTEME_SGO252VN_IRIX)) \
|| (defined(SYSTEME_SGPCM801_IRIX)) \
|| (defined(SYSTEME_SGPCMA01_IRIX)) \
)
#Eifdef BUG_SYSTEME_COMMANDE_SYSTEM_1
#ifdef __VERSION__GENERATION_D_UN_NUCLEON
# define FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
FEU_feu_nucleon_LX_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
/* Nom du feu de synchronisation pour l'enregistrement des images... */
#Aifdef __VERSION__GENERATION_D_UN_NUCLEON
#Eifdef __VERSION__GENERATION_D_UN_NUCLEON
#ifdef __VERSION__GENERATION_D_UN_MESON
# define FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
FEU_feu_meson_LX_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
/* Nom du feu de synchronisation pour l'enregistrement des images... */
#Aifdef __VERSION__GENERATION_D_UN_MESON
#Eifdef __VERSION__GENERATION_D_UN_MESON
#ifdef __VERSION__GENERATION_DU_VIDE
# define FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
FEU_feu_vide_LX_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
/* Nom du feu de synchronisation pour l'enregistrement des images... */
#Aifdef __VERSION__GENERATION_DU_VIDE
#Eifdef __VERSION__GENERATION_DU_VIDE
#ifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
# define FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
FEU_feu_di_elect_LX_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS \
/* Nom du feu de synchronisation pour l'enregistrement des images... */
#Aifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
#Eifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
#if ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
# TestADef NOMBRE_D_IMAGES_SIMULTANEES_MOINS_UNE \
NOMBRE_DE_PERIODES_DE_LA_SIMULATION \
/* Le passage de '#define' a '#TestADef' a eu lieu le 20111028213309... */
#Aif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#Eif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#if (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
# TestADef NOMBRE_D_IMAGES_SIMULTANEES_MOINS_UNE \
NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \
/* Le passage de '#define' a '#TestADef' a eu lieu le 20111028213309... */
#Aif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
#Eif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
DEFV(Local,DEFV(Positive,INIT(nombre_d_images_simultanees_moins_une,NOMBRE_D_IMAGES_SIMULTANEES_MOINS_UNE)));
/* Nombre d'images consecutives simultanees moins une (par exemple, si l'on donne 8 comme */
/* argument, il pourra y avoir 9=8+1 images au maximum en attente) ; ceci permet dans le */
/* cas d'un enregistrement de permettre plus d'asynchronisme que par le recours au feu */
/* 'FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS'... */
DEFV(Local,DEFV(Positive,INIT(nombre_d_images_generees,ZERO)));
/* Nombre d'images deja generees... */
#define SYNCHRONISER_LA_GENERATION_DES_IMAGES \
FAUX
DEFV(Local,DEFV(Logical,INIT(synchroniser_la_generation_des_images,SYNCHRONISER_LA_GENERATION_DES_IMAGES)));
/* Indicateur disant si la generation des images doit etre synchronise sur le feu rouge de */
/* nom 'FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS'. */
#define GENERATION_D_UNE_IMAGE(numero_de_l_image,numero_de_la_premiere_a_generer) \
Bblock \
Test(IFGE(numero_de_l_image,numero_de_la_premiere_a_generer)) \
Bblock \
CONVOLUTION_D_UNE_COMPOSANTE(Image_ROUGE); \
CONVOLUTION_D_UNE_COMPOSANTE(Image_VERTE); \
CONVOLUTION_D_UNE_COMPOSANTE(Image_BLEUE); \
/* Convolution eventuelle des composantes afin de limiter l'aliasing principalement sur les */ \
/* images fixes... */ \
CUMUL_D_UNE_COMPOSANTE_POUR_LE_CALCUL_DES_TRAINEES(Image_ROUGE \
,TRAINEES_ROUGE \
,trainee_du_ROUGE_avant \
,trainee_du_ROUGE_apres \
,numero_de_l_image \
); \
CUMUL_D_UNE_COMPOSANTE_POUR_LE_CALCUL_DES_TRAINEES(Image_VERTE \
,TRAINEES_VERTE \
,trainee_du_VERTE_avant \
,trainee_du_VERTE_apres \
,numero_de_l_image \
); \
CUMUL_D_UNE_COMPOSANTE_POUR_LE_CALCUL_DES_TRAINEES(Image_BLEUE \
,TRAINEES_BLEUE \
,trainee_du_BLEUE_avant \
,trainee_du_BLEUE_apres \
,numero_de_l_image \
); \
/* Calcul eventuel des trainees. ATTENTION : apres chaque calcul de l'effet de trainees, */ \
/* la composante courante subit, si necessaire, 'CONVOLUTION_D_UNE_COMPOSANTE(...)'... */ \
MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_ROUGE,Image_ROUGE); \
MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_VERTE,Image_VERTE); \
MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(TRAINEES_BLEUE,Image_BLEUE); \
/* Mise a jour des cumuls pour le calcul des trainees suivantes ; cette mise a jour est */ \
/* faite avant l'eventuel renormalisation des composantes, afin de ne pas prendre en compte */ \
/* des images renormalisees lors du calcul des trainees... */ \
RENORMALISATION_EVENTUELLE_D_UNE_COMPOSANTE(Image_ROUGE,trainee_du_ROUGE_avant,trainee_du_ROUGE_apres); \
RENORMALISATION_EVENTUELLE_D_UNE_COMPOSANTE(Image_VERTE,trainee_du_VERTE_avant,trainee_du_VERTE_apres); \
RENORMALISATION_EVENTUELLE_D_UNE_COMPOSANTE(Image_BLEUE,trainee_du_BLEUE_avant,trainee_du_BLEUE_apres); \
/* Puis, avant de memoriser les composantes, mais apres avoir mis a jour le systeme de */ \
/* calcul des trainees, les composantes sont eventuellement renormalisees... */ \
REMONTEE_DU_NIVEAU_DE_NOIR(Image_ROUGE,Image_ROUGE,niveau_de_NOIR_remonte); \
REMONTEE_DU_NIVEAU_DE_NOIR(Image_VERTE,Image_VERTE,niveau_de_NOIR_remonte); \
REMONTEE_DU_NIVEAU_DE_NOIR(Image_BLEUE,Image_BLEUE,niveau_de_NOIR_remonte); \
/* Enfin, avant de memoriser les composantes, mais apres avoir mis a jour le systeme de */ \
/* calcul des trainees, le niveau de noir est eventuellement remonte... */ \
TEST_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_ROUGE \
,COND(IFGT(nombre_d_images_generees \
,nombre_d_images_simultanees_moins_une \
) \
,SOUS(numero_de_l_image \
,nombre_d_images_simultanees_moins_une \
) \
,numero_de_l_image \
) \
) \
); \
TEST_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_VERTE \
,COND(IFGT(nombre_d_images_generees \
,nombre_d_images_simultanees_moins_une \
) \
,SOUS(numero_de_l_image \
,nombre_d_images_simultanees_moins_une \
) \
,numero_de_l_image \
) \
) \
); \
TEST_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_BLEUE \
,COND(IFGT(nombre_d_images_generees \
,nombre_d_images_simultanees_moins_une \
) \
,SOUS(numero_de_l_image \
,nombre_d_images_simultanees_moins_une \
) \
,numero_de_l_image \
) \
) \
); \
/* Et on attend eventuellement de la place... */ \
GENERATION_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_ROUGE \
,numero_de_l_image \
) \
,Image_ROUGE \
); \
GENERATION_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_VERTE \
,numero_de_l_image \
) \
,Image_VERTE \
); \
GENERATION_D_UNE_COMPOSANTE(NOM_DE_L_IMAGE(nom_imageR \
,c_BLEUE \
,numero_de_l_image \
) \
,Image_BLEUE \
); \
/* Memorisation de l'image en vraies couleurs. On notera que le nom d'une composante est */ \
/* de la forme (en ce qui concerne le style "ancien"...) : */ \
/* */ \
/* <racine><composante><numero> */ \
/* */ \
/* et non pas : */ \
/* */ \
/* <racine><numero><composante> */ \
/* */ \
/* en effet, cela permet ensuite de manipuler tout un ensemble de composantes chromatiques */ \
/* a l'aide d'un programme tel '$xci/accumule.01$K'. Par contre le style "nouveau" utilise */ \
/* la deuxieme syntaxe... */ \
INCR(nombre_d_images_generees,I); \
/* Comptage des images generees... */ \
Test(IL_FAUT(synchroniser_la_generation_des_images)) \
Bblock \
ATTENDRE_AU_FEU_ROUGE(FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS); \
/* On attend au prealable que le feu soit vert, */ \
MISE_DU_FEU_AU_ROUGE(FEU_feu_DE_SYNCHRONISATION_DE_LA_SIMULATION_DES_HADRONS); \
/* Et des qu'il est vert, on le remet au rouge... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Generation d'une image de numero donne... */