/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N C O M P L E X E --> ( R E E L L E , I M A G I N A I R E , M O D U L E , P H A S E ) : */
/* */
/* */
/* Author of '$xci/J_RIMP$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
#include image_image_IMAGESJ_EXT
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define DECALER_LES_NIVEAUX_DES_PARTIES_REELLE_ET_IMAGINAIRE \
VRAI \
/* Indique si l'on doit faire un 'IJscale(...)' si 'EST_VRAI(les_images_sont_standards)' */ \
/* ('VRAI') sur les parties Reelle et Imaginaire ou les laisser tel quel ('FAUX'). */
#define CALCULER_LE_MODULE_ET_LA_PHASE \
VRAI \
/* Faut-il calculer le module et la phase ('VRAI') ou uniquement les parties Reelle et */ \
/* Imaginaire ('FAUX') ? Ceci a ete introduit le 20030210114649. */
#define PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE_POUR_LE_MODULE \
FAUX \
/* Faut-il prendre une dynamique logarithmique ('VRAI') pour le module ou le laisser tel */ \
/* qu'il a ete calcule ('FAUX') ? */
#define ECHELLE_DE_CUTOFF \
FZERO \
/* L'echelle de "cutoff" est dans [0,1] ; pour '0' tout est conserve, alors que pour '1' */ \
/* tout est supprime (et remplace par le marqueur des niveaux faibles...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define TRANSLATION_DES_NIVEAUX_FAIBLES \
DOUB(DIVI(SOUS(maximum_de_la_phase,minimum_de_la_phase),FLOT(COULEURS))) \
/* Pour passer du minimum de la phase au niveau de marquage des points correspondants a */ \
/* a une faible valeur du module ("cutoff"). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N C O M P L E X E --> ( R E E L L E , I M A G I N A I R E , M O D U L E , P H A S E ) : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageRR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRI),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRP),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRM),NOM_PIPE));
/* Nom des quatre images resultat (Reelle, Imaginaire, Phase, Module). */
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
/* Nom de l'image complexe que l'on va convertir. */
DEFV(Logical,INIT(calculer_le_module_et_la_phase,CALCULER_LE_MODULE_ET_LA_PHASE));
/* Faut-il calculer le module et la phase ('VRAI') ou uniquement les parties Reelle et */
/* Imaginaire ('FAUX') ? Ceci a ete introduit le 20030210114649. */
DEFV(genere_Float,INIT(minimum_reel,FLOT__UNDEF));
DEFV(genere_Float,INIT(maximum_reel,FLOT__UNDEF));
/* Donnent le minimum et le maximum de la partie reelle de l'image Argument, */
DEFV(genere_Float,INIT(minimum_imaginaire,FLOT__UNDEF));
DEFV(genere_Float,INIT(maximum_imaginaire,FLOT__UNDEF));
/* Donnent le minimum et le maximum de la partie imaginaire de l'image Argument. */
DEFV(genere_Float,INIT(minimum_du_module,FLOT__UNDEF));
DEFV(genere_Float,INIT(maximum_du_module,FLOT__UNDEF));
/* Donnent le minimum et le maximum du module de l'image Argument, */
DEFV(genere_Float,INIT(minimum_de_la_phase,FLOT__UNDEF));
DEFV(genere_Float,INIT(maximum_de_la_phase,FLOT__UNDEF));
/* Donnent le minimum et le maximum de la phase de l'image Argument. */
DEFV(Logical,INIT(decaler_les_niveaux_des_parties_Reelle_et_imaginaire,DECALER_LES_NIVEAUX_DES_PARTIES_REELLE_ET_IMAGINAIRE));
/* Indique si l'on doit faire un 'IJscale(...)' si 'EST_VRAI(les_images_sont_standards)' */
/* ('VRAI') sur les parties Reelle et Imaginaire ou les laisser tel quel ('FAUX'). */
DEFV(Logical,INIT(prendre_une_dynamique_logarithmique_pour_le_module,PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE_POUR_LE_MODULE));
/* Faut-il prendre une dynamique logarithmique ('VRAI') pour le module ou le laisser tel */
/* qu'il a ete calcule ('FAUX') ? */
DEFV(Float,INIT(echelle_de_cutoff,ECHELLE_DE_CUTOFF));
/* L'echelle de "cutoff" est dans [0,1] ; pour '0' tout est conserve, alors que pour '1' */
/* tout est supprime (et remplace par le marqueur des niveaux faibles...). */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("A=",nom_imageA);
GET_ARGUMENT_C("imageRR=""RR=",nom_imageRR);
GET_ARGUMENT_C("imageRI=""RI=",nom_imageRI);
GET_ARGUMENT_C("imageRM=""RM=",nom_imageRM);
GET_ARGUMENT_C("imageRP=""RP=",nom_imageRP);
GET_ARGUMENT_L("standard=",les_images_sont_standards);
GET_ARGUMENT_L("mp=""module_phase=",calculer_le_module_et_la_phase);
GET_ARGUMENT_L("decaler=",decaler_les_niveaux_des_parties_Reelle_et_imaginaire);
GET_ARGUMENT_L("logarithmique=""log=",prendre_une_dynamique_logarithmique_pour_le_module);
GET_ARGUMENT_F("cutoff=",echelle_de_cutoff);
)
);
CALi(Inoir(ImageA1));
CALi(Inoir(ImageA2));
CALi(Inoir(ImageA3));
CALi(Inoir(ImageA4));
CALi(IFinitialisation(IFmage_PR,FZERO));
CALi(IFinitialisation(IFmage_PI,FZERO));
CALi(IFinitialisation(IFmage_Mo,FZERO));
CALi(IFinitialisation(IFmage_Ph,FZERO));
/* Initialisation de quatre images Resultat avant le changement eventuel de (pasX,pasY). */
Test(PAS_D_ERREUR(CODE_ERROR(IloadJ_image(IJmageA,nom_imageA))))
Bblock
/* Acces a l'image Argument que l'on veut convertir en (R,I,M,P). */
CALS(Icomplexe_reelle(IFmage_PR,IJmageA));
CALS(Icomplexe_imaginaire(IFmage_PI,IJmageA));
/* Recuperation des parties reelles et imaginaires. */
Test(IL_FAUT(calculer_le_module_et_la_phase))
Bblock
CALS(Iconversion_XY_RT(IFmage_Mo,IFmage_Ph
,IFmage_PR,IFmage_PI
)
);
/* Calcul des modules et des phases dans [0,2.PI], */
Eblock
ATes
Bblock
Eblock
ETes
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas des images 'image' : */
Test(IL_FAUT(calculer_le_module_et_la_phase))
Bblock
CALS(IFnivo_extrema(IFmage_Mo
,ADRESSE(minimum_du_module)
,ADRESSE(maximum_du_module)
)
);
/* Recherche du minimum et du maximum du module de l'image Argument. */
CALS(IFnivo_extrema(IFmage_Ph
,ADRESSE(minimum_de_la_phase)
,ADRESSE(maximum_de_la_phase)
)
);
/* Recherche du minimum et du maximum de la phase de l'image Argument. */
CALS(IFcutoff(IFmage_Ph
,SOUS(minimum_de_la_phase,TRANSLATION_DES_NIVEAUX_FAIBLES)
,IFmage_Ph
,ADD2(minimum_du_module,MUL2(SOUS(maximum_du_module,minimum_du_module),echelle_de_cutoff))
,IFmage_Mo
)
);
/* Cutoff de la phase a l'aide du module... */
CALS(IFscale(IFmage_Ph
,DIVI(FLOT(COULEURS),ADD2(TRANSLATION_DES_NIVEAUX_FAIBLES,CERCLE_TRIGONOMETRIQUE))
,IFmage_Ph
,MUL2(DIVI(FLOT(COULEURS),ADD2(TRANSLATION_DES_NIVEAUX_FAIBLES,CERCLE_TRIGONOMETRIQUE))
,TRANSLATION_DES_NIVEAUX_FAIBLES
)
)
);
/* Calcul des phases dans [NOIR,BLANC]... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(decaler_les_niveaux_des_parties_Reelle_et_imaginaire))
Bblock
CALS(IFscale(IFmage_PR
,FU
,IFmage_PR
,FLOT(NEUT(MOIT(COULEURS)))
)
);
CALS(IFscale(IFmage_PI
,FU
,IFmage_PI
,FLOT(NEUT(MOIT(COULEURS)))
)
);
Eblock
ATes
Bblock
Eblock
ETes
CALS(IFnivo_extrema(IFmage_PR
,ADRESSE(minimum_reel)
,ADRESSE(maximum_reel)
)
);
/* Recherche du minimum et du maximum de la partie reelle de l'image Argument. */
Test(IFOU(IFGE(SOUS(FLOT__NOIR,minimum_reel),FU)
,IFGE(SOUS(maximum_reel,FLOT__BLANC),FU)
)
)
/* Nota : on n'oubliera pas que par definition 'minimum <= maximum'... */
Bblock
PRINT_ATTENTION("renormalisation de la partie reelle");
CAL1(Prer1("minimum=%.^^^\n"
,minimum_reel
)
);
/* Le 20060105154420, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123140, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CAL1(Prer1("maximum=%.^^^\n"
,maximum_reel
)
);
/* Le 20060105154420, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123140, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CALS(Ifloat_std(ImageA1
,IFmage_PR
,minimum_reel
,maximum_reel
)
);
/* A1 = generation de l'image "partie reelle" (avec renormalisation). */
/* lorsque les niveaux minimal et maximal sont hors de [NOIR,BLANC], on renormalise... */
Eblock
ATes
Bblock
CALS(Ifloat_std(ImageA1
,IFmage_PR
,FLOT__NOIR
,FLOT__BLANC
)
);
/* A1 = generation de l'image "partie reelle" (avec renormalisation). */
/* les niveaux minimal et maximal sont dans [NOIR,BLANC] et on */
/* ne renormalise pas... */
Eblock
ETes
CALS(IFnivo_extrema(IFmage_PI
,ADRESSE(minimum_imaginaire)
,ADRESSE(maximum_imaginaire)
)
);
/* Recherche du minimum et du maximum de la partie imaginaire de l'image Argument. */
Test(IFOU(IFGE(SOUS(FLOT__NOIR,minimum_imaginaire),FU)
,IFGE(SOUS(maximum_imaginaire,FLOT__BLANC),FU)
)
)
/* Nota : on n'oubliera pas que par definition 'minimum <= maximum'... */
Bblock
PRINT_ATTENTION("renormalisation de la partie imaginaire");
CAL1(Prer1("minimum=%.^^^\n"
,minimum_imaginaire
)
);
/* Le 20060105154420, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123140, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CAL1(Prer1("maximum=%.^^^\n"
,maximum_imaginaire
)
);
/* Le 20060105154420, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123140, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CALS(Ifloat_std(ImageA2
,IFmage_PI
,minimum_imaginaire
,maximum_imaginaire
)
);
/* A2 = generation de l'image "partie imaginaire" (avec renormalisation). */
/* lorsque les niveaux minimal et maximal sont hors de [NOIR,BLANC], on renormalise... */
Eblock
ATes
Bblock
CALS(Ifloat_std(ImageA2
,IFmage_PI
,FLOT__NOIR
,FLOT__BLANC
)
);
/* A2 = generation de l'image "partie imaginaire" (avec renormalisation). */
/* les niveaux minimal et maximal sont dans [NOIR,BLANC] et on */
/* ne renormalise pas... */
Eblock
ETes
Test(IL_FAUT(calculer_le_module_et_la_phase))
Bblock
Test(IL_FAUT(prendre_une_dynamique_logarithmique_pour_le_module))
Bblock
CALS(IFdynamique_logarithmique_avec_translation_dynamique(IFmage_Mo,IFmage_Mo));
/* S'il le faut, la dynamique du module est reduite par application d'une fonction */
/* logarithme... */
Eblock
ATes
Bblock
Eblock
ETes
CALS(Ifloat_std_avec_renormalisation(ImageA3
,IFmage_Mo
)
);
/* A3 = generation de l'image "module" (avec renormalisation). */
CALS(Ifloat_std(ImageA4
,IFmage_Ph
,FLOT__NOIR
,FLOT__BLANC
)
);
/* A4 = generation de l'image "phase" (sans renormalisation, afin de conserver toute */
/* l'information, et en particulier voir des "trous" dans [0,2.PI]). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas des images 'imageF' : */
Test(IL_FAUT(calculer_le_module_et_la_phase))
Bblock
Test(IL_FAUT(prendre_une_dynamique_logarithmique_pour_le_module))
Bblock
CALS(IFdynamique_logarithmique_avec_translation_dynamique(IFmage_Mo,IFmage_Mo));
/* S'il le faut, la dynamique du module est reduite par application d'une fonction */
/* logarithme... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
CALi(gIupdate_image(les_images_sont_standards,nom_imageRR,ImageA1,IFmage_PR));
CALi(gIupdate_image(les_images_sont_standards,nom_imageRI,ImageA2,IFmage_PI));
Test(IL_FAUT(calculer_le_module_et_la_phase))
Bblock
CALi(gIupdate_image(les_images_sont_standards,nom_imageRM,ImageA3,IFmage_Mo));
CALi(gIupdate_image(les_images_sont_standards,nom_imageRP,ImageA4,IFmage_Ph));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
RETU_Commande;
Eblock
ECommande
Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.