/*************************************************************************************************************************************/
/* */
/* C O M B I N A I S O N U N I V E R S E L L E V A R I A B L E D E D E U X I M A G E S F L O T T A N T E S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande genere une image */
/* dont le nom est le premier argument */
/* d'appel ; elle est le resultat de */
/* la combinaison universelle variable */
/* des deux images Arguments. */
/* */
/* */
/* Author of '$xci/CombinaisonUniverselleVariable.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20181118120434). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#define GENERER_LES_GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
/* Introduit le 20191101103844 pour 'MULH24(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 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. */
#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'). */
#define NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE \
UN \
/* Soit N le nombre d'iterations de la puissance ; 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 : */
/* */
/*************************************************************************************************************************************/
#define COMBINAISON_UNIVERSELLE_VARIABLE(imageR,imageA1,imageA2) \
Bblock \
CALS(IFcombinaison_universelle_variable(imageR \
,imageA1 \
,imageA2 \
,image____ADD2 \
,image____SOUS \
,image____MUL2 \
,image____DIVZ \
,image____MIN2 \
,image____MAX2 \
,image__MINMAX \
,image__MAXMIN \
,image____MOYE \
,image____MOYZ \
,image__MOYZSI \
,image____MOYQ \
,image__MOYQSI \
,image____MOYH \
,image___SPUIX \
,image____ATAN \
,image__MULH24 \
) \
); \
Eblock \
/* Combinaison universelle variable... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M B I N A I S O N U N I V E R S E L L E V A R I A B L E D E D E U X I M A G E S F L O T T A N T E S : */
/* */
/*************************************************************************************************************************************/
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(CHAR,INIC(POINTERc(nom_image____ADD2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____SOUS),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MUL2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____DIVZ),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MIN2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MAX2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image__MINMAX),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image__MAXMIN),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MOYE),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MOYZ),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image__MOYZSI),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MOYQ),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image__MOYQSI),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____MOYH),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image___SPUIX),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image____ATAN),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image__MULH24),NOM_PIPE));
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. */
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'). */
DEFV(Positive,INIT(nombre_d_iterations_de_la_puissance,NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE));
/* Soit N le nombre d'iterations de la puissance ; 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);
GET_ARGUMENT_C("imageA2=""A2=",nom_imageA2);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_C("pADD2=",nom_image____ADD2);
GET_ARGUMENT_C("pSOUS=",nom_image____SOUS);
GET_ARGUMENT_C("pMUL2=",nom_image____MUL2);
GET_ARGUMENT_C("pDIVZ=",nom_image____DIVZ);
GET_ARGUMENT_C("pMIN2=",nom_image____MIN2);
GET_ARGUMENT_C("pMAX2=",nom_image____MAX2);
GET_ARGUMENT_C("pMINMAX=",nom_image__MINMAX);
GET_ARGUMENT_C("pMAXMIN=",nom_image__MAXMIN);
GET_ARGUMENT_C("pMOYE=",nom_image____MOYE);
GET_ARGUMENT_C("pMOYZ=",nom_image____MOYZ);
GET_ARGUMENT_C("pMOYZSI=",nom_image__MOYZSI);
GET_ARGUMENT_C("pMOYQ=",nom_image____MOYQ);
GET_ARGUMENT_C("pMOYQSI=",nom_image__MOYQSI);
GET_ARGUMENT_C("pMOYH=",nom_image____MOYH);
GET_ARGUMENT_C("pSPUIX=",nom_image___SPUIX);
GET_ARGUMENT_C("pATAN=",nom_image____ATAN);
GET_ARGUMENT_C("pMULH24=",nom_image__MULH24);
/* Le 20181121152353, l'entree du nom des images de Ponderation a ete precede d'un "p" */
/* (ainsi, par exemple, "ADD2=" est devenu "pADD2=") afin de faciliter leur recuperation */
/* automatique (comme dans 'v $xiirv/.HORN.11.2.$U .xci.ProduitHorner_2_04.01'pour ce qui */
/* est du programme 'v $xci/ProduitHorner_2_04.01$K a44=' par exemple)... */
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
)
);
GET_ARGUMENT_I("iterations=""nombre_carres=""nombre=""n=",nombre_d_iterations_de_la_puissance);
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
)
);
)
);
CALi(IFinitialisation(IFmageR,FZERO));
/* Initialisation de l'image Resultat. */
begin_nouveau_block
Bblock
BDEFV(imageF,image____ADD2);
BDEFV(imageF,image____SOUS);
BDEFV(imageF,image____MUL2);
BDEFV(imageF,image____DIVZ);
BDEFV(imageF,image____MIN2);
BDEFV(imageF,image____MAX2);
BDEFV(imageF,image__MINMAX);
BDEFV(imageF,image__MAXMIN);
BDEFV(imageF,image____MOYE);
BDEFV(imageF,image____MOYZ);
BDEFV(imageF,image__MOYZSI);
BDEFV(imageF,image____MOYQ);
BDEFV(imageF,image__MOYQSI);
BDEFV(imageF,image____MOYH);
BDEFV(imageF,image___SPUIX);
BDEFV(imageF,image____ATAN);
BDEFV(imageF,image__MULH24);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____ADD2,nom_image____ADD2,NOM_PIPE,FU);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____SOUS,nom_image____SOUS,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MUL2,nom_image____MUL2,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____DIVZ,nom_image____DIVZ,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MIN2,nom_image____MIN2,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MAX2,nom_image____MAX2,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image__MINMAX,nom_image__MINMAX,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image__MAXMIN,nom_image__MAXMIN,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MOYE,nom_image____MOYE,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MOYZ,nom_image____MOYZ,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image__MOYZSI,nom_image__MOYZSI,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MOYQ,nom_image____MOYQ,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image__MOYQSI,nom_image__MOYQSI,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____MOYH,nom_image____MOYH,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image___SPUIX,nom_image___SPUIX,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image____ATAN,nom_image____ATAN,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image__MULH24,nom_image__MULH24,NOM_PIPE,FZERO);
Test(IL_NE_FAUT_PAS(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux))
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA1,nom_imageA1))))
Bblock
/* Chargement de la premiere image Argument. */
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA2,nom_imageA2))))
Bblock
/* Chargement de la deuxieme image Argument. */
CALS(COMBINAISON_UNIVERSELLE_VARIABLE(IFmageR
,IFmageA1
,IFmageA2
)
);
/* Et produit des deux images arguments 'ImageA1' et 'ImageA2'. */
CALi(IupdateF_image(nom_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))
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(IloadF_image(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(IFmove(IFmageA1,IFmageR));
CALS(IFinitialisation(IFmageR,FU));
Repe(nombre_d_iterations_de_la_puissance)
Bblock
CALS(COMBINAISON_UNIVERSELLE_VARIABLE(IFmageR
,IFmageR
,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(IFmove(IFmageA1,IFmageR));
CALS(COMBINAISON_UNIVERSELLE_VARIABLE(IFmageR
,IFmageA1
,IFmageA1
)
);
/* Elevation a la puissance 2^N de l'image Argument unique. */
Eblock
ERep
Eblock
ETes
CALi(IupdateF_image(nom_imageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
EDEFV(imageF,image__MULH24);
EDEFV(imageF,image____ATAN);
EDEFV(imageF,image___SPUIX);
EDEFV(imageF,image____MOYH);
EDEFV(imageF,image__MOYQSI);
EDEFV(imageF,image____MOYQ);
EDEFV(imageF,image__MOYZSI);
EDEFV(imageF,image____MOYZ);
EDEFV(imageF,image____MOYE);
EDEFV(imageF,image__MAXMIN);
EDEFV(imageF,image__MINMAX);
EDEFV(imageF,image____MAX2);
EDEFV(imageF,image____MIN2);
EDEFV(imageF,image____DIVZ);
EDEFV(imageF,image____MUL2);
EDEFV(imageF,image____SOUS);
EDEFV(imageF,image____ADD2);
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande