/*************************************************************************************************************************************/
/* */
/* P R O D U I T A R I T H M E T I Q U E D E D E U X I M A G E S A V E C R E N O R M A L I S A T I O N : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande genere une image */
/* dont le nom est le premier argument */
/* d'appel ; elle est le resultat du */
/* produit des deux images Arguments, */
/* avec renormalisation du resultat. */
/* */
/* */
/* Author of '$xci/multi_02.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1989??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
#include image_image_IMAGESF_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define LES_IMAGES_STANDARDS_SONT_A_RENORMALISER \
VRAI \
/* Indique s'il faut ('VRAI') ou pas ('FAUX') renormaliser les images standard (ceci a ete */ \
/* introduit le 20040921093852). */
#define CALCULER_LA_PUISSANCE_2_PUISSANCE_N_D_UNE_IMAGE_PLUTOT_QU_UN_PRODUIT_DE_DEUX \
FAUX \
/* Indique s'il faut ('VRAI') ou pas ('FAUX') calculer plutot le "carre" d'une image. Ceci */ \
/* a ete introduit le 20110916142503 explicitement a fin de pouvoir etre utilise dans un */ \
/* "pipe" car, en effet, on pouvait au prealable calculer le carre d'une image en donnant */ \
/* en arguments "A1=" et "A2=" deux fois la meme image, mais evidemment cela ne marchait */ \
/* pas a l'interieur d'un "pipe"... */
#define CALCULER_LA_PUISSANCE_N_PLUTOT_QUE_LA_PUISSANCE_2_PUISSANCE_N \
FAUX \
/* Indique s'il faut en fait calculer une puissance ('VRAI') plutot qu'un "carre" ('FAUX'). */ \
/* Ceci a ete introduit le 20150610133454... */
#define NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE \
UN \
/* Le 20140827150918 a ete introduite la possibilite d'iterer la puissance. Soit N ce */ \
/* nombre d'iterations ; deux cas se presentent alors : */ \
/* */ \
/* IL_NE_FAUT_PAS(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */ \
/* L'image Argument est elevee a la puissance 2^N. */ \
/* */ \
/* IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */ \
/* L'image Argument est elevee a la puissance N. */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O D U I T A R I T H M E T I Q U E D E D E U X I M A G E S A V E C R E N O R M A L I S A T I O N : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA1),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA2),NOM_PIPE));
DEFV(Logical,INIT(les_images_standards_sont_a_renormaliser,LES_IMAGES_STANDARDS_SONT_A_RENORMALISER));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') renormaliser les images standard (ceci a ete */
/* introduit le 20040921093852). */
DEFV(Logical,INIT(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
,CALCULER_LA_PUISSANCE_2_PUISSANCE_N_D_UNE_IMAGE_PLUTOT_QU_UN_PRODUIT_DE_DEUX
)
);
/* Indique s'il faut ('VRAI') ou pas ('FAUX') calculer plutot le "carre" d'une image. Ceci */
/* a ete introduit le 20110916142503 explicitement a fin de pouvoir etre utilise dans un */
/* "pipe" car, en effet, on pouvait au prealable calculer le carre d'une image en donnant */
/* en arguments "A1=" et "A2=" deux fois la meme image, mais evidemment cela ne marchait */
/* pas a l'interieur d'un "pipe"... */
DEFV(Logical,INIT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N
,CALCULER_LA_PUISSANCE_N_PLUTOT_QUE_LA_PUISSANCE_2_PUISSANCE_N
)
);
/* Indique s'il faut en fait calculer une puissance ('VRAI') plutot qu'un "carre" ('FAUX'). */
/* Ceci a ete introduit le 20150610133454... */
DEFV(Positive,INIT(nombre_d_iterations_de_la_puissance,NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE));
/* Le 20140827150918 a ete introduite la possibilite d'iterer la puissance. Soit N ce */
/* nombre d'iterations ; deux cas se presentent alors : */
/* */
/* IL_NE_FAUT_PAS(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */
/* L'image Argument est elevee a la puissance 2^N. */
/* */
/* IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */
/* L'image Argument est elevee a la puissance N. */
/* */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA1=""A1=""imageA=""A=",nom_imageA1);
/* Les arguments "imageA=" et "A=" ont ete introduits le 20110916142503... */
GET_ARGUMENT_C("imageA2=""A2=",nom_imageA2);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_L("standard=",les_images_sont_standards);
GET_ARGUMENT_L("rn=""renormaliser=""r=",les_images_standards_sont_a_renormaliser);
GET_ARGUMENT_L("message_extrema=""me=",Ifloat_std_____editer_le_message_d_attention_relatif_aux_extrema);
/* Option introduite le 20190717125427... */
GET_ARGUMENT_L("carre_image=""ci=""c=""exponentiation_image=""expi="
,calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
);
GET_ARGUMENT_N("produit_images=""pi=""p="
,calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
);
PROCESS_ARGUMENT_L("puissance_image=""puis="
,calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N
,BLOC(VIDE;)
,BLOC(
Bblock
EGAL(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
,VRAI
);
/* Cette argument est force a priori... */
Eblock
)
);
/* Argument introduit le 20150610133454... */
GET_ARGUMENT_I("iterations=""nombre_carres=""nombre=""n=",nombre_d_iterations_de_la_puissance);
/* Arguments introduits le 20110916142503 et completes le 20140827150918... */
PROCESS_ARGUMENT_I("exposant=""exp="
,nombre_d_iterations_de_la_puissance
,BLOC(VIDE;)
,BLOC(
Bblock
Test(IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N))
Bblock
Eblock
ATes
Bblock
Test(IZGT(nombre_d_iterations_de_la_puissance))
Bblock
Eblock
ATes
Bblock
PRINT_ATTENTION("l'exposant est negatif ou nul");
EGAL(nombre_d_iterations_de_la_puissance
,NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE
);
CAL1(Prer1("(la valeur par defaut (%d) est forcee)\n"
,nombre_d_iterations_de_la_puissance
)
);
Eblock
ETes
EGAL(nombre_d_iterations_de_la_puissance
,INTE(LO2X(nombre_d_iterations_de_la_puissance))
);
/* On notera qu'evidemment, la valeur de 'LO2X(...)' est rarement entiere... */
Eblock
ETes
Eblock
)
);
/* Arguments introduits le 20150123100555... */
GET_ARGUMENT_L("calculer_niveau_extrema_egaux=""cnee="
,Ifloat_std_____calculer_le_niveau_plancher_a_utiliser_si_les_extrema_sont_egaux
);
/* Options introduite le 20200506174538 pour 'v $Fdivers GProfilP'... */
)
);
CALi(gInettoyage(les_images_sont_standards,ImageR,IFmageR));
/* Initialisation de l'image Resultat. */
Test(IL_NE_FAUT_PAS(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux))
Bblock
/* Test introduit le 20110916142503... */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA1,IFmageA1,nom_imageA1))))
Bblock
/* Chargement de la premiere image Argument. */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA2,IFmageA2,nom_imageA2))))
Bblock
/* Chargement de la deuxieme image Argument. */
CALS(gImultiplication(les_images_sont_standards
,les_images_standards_sont_a_renormaliser
,ImageR,IFmageR
,ImageA1,IFmageA1
,ImageA2,IFmageA2
)
);
/* Et produit des deux images arguments 'ImageA1' et 'ImageA2'. */
CALi(gIupdate_image(les_images_sont_standards,nom_imageR,ImageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test(IFNE_chaine(nom_imageA2,NOM_PIPE))
/* Validation introduite le 20110916152952... */
Bblock
PRINT_ATTENTION("lors du calcul du carre d'une image, un seul nom doit etre donne");
Eblock
ATes
Bblock
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageR,IFmageR,nom_imageA1))))
Bblock
/* Chargement de l'image Argument unique. */
Test(IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N))
Bblock
CALS(gImove(les_images_sont_standards,ImageA1,IFmageA1,ImageR,IFmageR));
CALS(gIIinitialisation(les_images_sont_standards,ImageR,IFmageR,UN,FU));
Repe(nombre_d_iterations_de_la_puissance)
Bblock
CALS(gImultiplication(les_images_sont_standards
,les_images_standards_sont_a_renormaliser
,ImageR,IFmageR
,ImageR,IFmageR
,ImageA1,IFmageA1
)
);
/* Elevation a la puissance N de l'image Argument unique. */
Eblock
ERep
Eblock
ATes
Bblock
Repe(NEUT(nombre_d_iterations_de_la_puissance))
Bblock
CALS(gImove(les_images_sont_standards,ImageA1,IFmageA1,ImageR,IFmageR));
CALS(gImultiplication(les_images_sont_standards
,les_images_standards_sont_a_renormaliser
,ImageR,IFmageR
,ImageA1,IFmageA1
,ImageA1,IFmageA1
)
);
/* Elevation a la puissance 2^N de l'image Argument unique. */
Eblock
ERep
Eblock
ETes
CALi(gIupdate_image(les_images_sont_standards,nom_imageR,ImageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
RETU_Commande;
Eblock
ECommande