/*************************************************************************************************************************************/
/* */
/* F I L T R A G E D ' U N E I M A G E P A R T R A N S F O R M E E D E F O U R I E R C O M P L E X E : */
/* */
/* */
/* Definition : */
/* */
/* En notant '*' le produit terme a */
/* terme de deux matrices complexes, le */
/* le resultat de cette commande est */
/* l'image : */
/* */
/* -1 */
/* TF (TF(image)*TF(noyau)) */
/* */
/* ou 'image' et 'noyau' designent l'image */
/* a filtrer et le noyau respectivement. */
/* */
/* */
/* Remarque sur certaines invariances : */
/* */
/* Le 20181109111259, j'ai fait des experiences */
/* pour verifier, par exemple, l'invariance */
/* de la 'TF' par transposition. Soit 'image' une */
/* image carree ('Std' par exemple). On calcule */
/* les deux 'TF's suivantes : */
/* */
/* image1 = TF(image) */
/* image2 = TRANPOSITION(TF(TRANPOSITION(image))) */
/* */
/* Les deux images 'image1' et 'image2' sont */
/* absolument identiques, d'ou l'invariance... */
/* */
/* */
/* Author of '$xci/filtre.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1988??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 PRAGMA_CPP_____POUR_LES_Iload_NE_PAS_VERIFIER_LES_MULTIPLES_UTILISATIONS_DE_L_IMAGE_____ImageA3
@define PRAGMA_CPP_____POUR_LES_Iload_NE_PAS_VERIFIER_LES_MULTIPLES_UTILISATIONS_DE_L_IMAGE_____ImageA4
/* Introduit le 20060124092138. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 maths_trans_FOURIER_EXT
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/filtre.01.I"
#define RESPECTER_LES_EXTREMA_DE_L_IMAGE_ARGUMENT \
FAUX \
/* Indique si l'on doit respecter les extrema de 'ImageA' pour 'ImageR' dans le cas standard */ \
/* ('VRAI') ou pas ('FAUX'), c'est-a-dire exploiter {NOIR,BLANC} comme c'etait le cas avant */ \
/* le 20011215102450. */
#define FILTRER \
VRAI \
/* Indique si l'on doit filtrer l'image Argument ('VRAI') ou juste faire 'FFT(FFT-1(...))' */ \
/* ('FAUX'). */
#define EDITER_LES_EXTREMA \
FAUX \
/* Indique si l'on doit editer les extrema ('VRAI') ou pas ('FAUX'). Ceci fut introduit le */ \
/* 20240708081512... */
#define TRANSLATIONS_DIRECTES \
VRAI \
/* Indique si l'on doit passer de {X_translate,Y_translate} a {X,Y} ('VRAI') ou l'inverse, */ \
/* c'est-a-dire passer de {X,Y} a {X_translate,Y_translate} ('FAUX'). */
#define AVERTIR_S_IL_Y_A_REDIMENSIONNEMENT \
FAUX \
/* Indique si l'on doit avertir lorsqu'il y a redimensionnement ('VRAI') ou pas ('FAUX'). */
#define METHODE_DE_REDIMENSIONNEMENT_A_UTILISER_POUR_LES_IMAGES \
REECHANTILLONNAGE_PAR_INTERPOLATION_BILINEAIRE
#define METHODE_DE_REDIMENSIONNEMENT_A_UTILISER_POUR_LES_NOYAUX \
REECHANTILLONNAGE_SANS_REECHANTILLONNAGE_AVEC_MISE_AU_CENTRE
/* Methode de redimensionnement a utiliser si besoin est (introduit le 20210106151223 et */
/* complete le 20210107100532)... */
#define AVERTIR_EN_PRESENCE_D_UN_NOYAU_DE_FILTRAGE_NON_IMPLICITE \
VRAI \
/* Indique si l'on doit avertir lorsque le noyau n'est pas implicite (introduit le */ \
/* 20060515112945). */
#define COMPATIBILITE_20030910 \
FAUX \
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */ \
/* au 20030910092458. */
#define COMPATIBILITE_20210106 \
FAUX \
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */ \
/* au 20210106151223. */
#define COMPATIBILITE_20210107 \
FAUX \
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */ \
/* au 20210107100147. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define DEFINITION_DU_NOIR_BLANC_DE_ImageA \
Bblock \
DEFV(pointF_2D,point_minimum); \
DEFV(pointF_2D,point_maximum); \
/* Definitions necessaires pour appeler 'Inivo_extrema(...)'... */ \
\
CALS(Inivo_extrema(ImageA \
,ADRESSE(Ifloat_std_____niveau_NOIR),ADRESSE(point_minimum) \
,ADRESSE(Ifloat_std_____niveau_BLANC),ADRESSE(point_maximum) \
) \
); \
/* Positionnement du {NOIR,BLANC} effectif pour le 'Ifloat_std(...)' ulterieur. */ \
Eblock \
/* Definition de {NOIR,BLANC} destine a 'Ifloat_std(...)'. ATTENTION, le fait de modifier */ \
/* {Ifloat_std_____niveau_NOIR,Ifloat_std_____niveau_BLANC} dans le code meme de la */ \
/* fonction 'Ifloat_std(...)' pourrait etre tres dangereux si cette fonction etait appelee */ \
/* ci-apres plusieurs fois de suite dans des "roles" differents... */
#define GENERATION_DE_formatI_Sxu \
chain_Aconcaten8(" Xmin=" \
,chain_Aentier(COORDONNEE_MINIMALE) \
," Xmax=" \
,chain_Aentier(COORDONNEE_MAXIMALE(logarithme_entier_en_base_2_de_la_plus_grande_dimension)) \
," Ymin=" \
,chain_Aentier(COORDONNEE_MINIMALE) \
," Ymax=" \
,chain_Aentier(COORDONNEE_MAXIMALE(logarithme_entier_en_base_2_de_la_plus_grande_dimension)) \
)
#define GENERATION_DE_formatR_Sxu \
chain_Aconcaten8(" XminR=" \
,chain_Aentier(COORDONNEE_MINIMALE) \
," XmaxR=" \
,chain_Aentier(COORDONNEE_MAXIMALE(logarithme_entier_en_base_2_de_la_plus_grande_dimension)) \
," YminR=" \
,chain_Aentier(COORDONNEE_MINIMALE) \
," YmaxR=" \
,chain_Aentier(COORDONNEE_MAXIMALE(logarithme_entier_en_base_2_de_la_plus_grande_dimension)) \
)
/* Afin de passer au format carre et puissance de 2 immediatement superieur (ceci fut */
/* introduit le 20120906174241 et le probleme n'avait pas ete vu avant !)... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H O I X D E L A F A C O N D ' I M P L E M E N T E R L E S T R A N S F O R M E E S : */
/* */
/*************************************************************************************************************************************/
#include xci/filtre.02.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I L T R A G E D ' U N E I M A G E P A R T R A N S F O R M E E D E F O U R I E R C O M P L E X E : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom de l'image Resultat filtree. */
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
/* Nom de l'image Argument a filtrer. */
DEFV(CHAR,INIC(POINTERc(nom_noyauNM),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_noyauNA),NOM_PIPE));
/* Nom des noyaux de filtrage. */
DEFV(CHAR,INIC(POINTERc(nom_image_translation_horizontale),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_image_translation_verticale),NOM_UNDEF));
/* Nom des deux images optionnelles destinees a translater la transformee de Fourier de */
/* l'image Argument avant filtrage. ATTENTION, ces deux images doivent etre presentes */
/* simultanement pour qu'elles soient appliquees... */
DEFV(CHAR,INIC(POINTERc(nom_image_deplacement_horizontal),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_image_deplacement_vertical),NOM_UNDEF));
/* Nom des deux images optionnelles deplacer a modifier la transformee de Fourier de */
/* l'image Argument avant filtrage. ATTENTION, ces deux images doivent etre presentes */
/* simultanement pour qu'elles soient appliquees... */
DEFV(Logical,INIT(filtrer,FILTRER));
/* Indique si l'on doit filtrer l'image Argument ('VRAI') ou juste faire 'FFT(FFT-1(...))' */
/* ('FAUX'). */
DEFV(Logical,INIT(editer_les_extrema,EDITER_LES_EXTREMA));
/* Indique si l'on doit editer les extrema ('VRAI') ou pas ('FAUX'). Ceci fut introduit le */ \
/* 20240708081512... */
#include xci/filtre.03.I"
DEFV(Logical,INIT(respecter_les_extrema_de_l_image_Argument,RESPECTER_LES_EXTREMA_DE_L_IMAGE_ARGUMENT));
/* Indique si l'on doit respecter les extrema de 'ImageA' pour 'ImageR' dans le cas standard */
/* ('VRAI') ou pas ('FAUX'), c'est-a-dire exploiter {NOIR,BLANC} comme c'etait le cas avant */
/* le 20011215102450. */
DEFV(Logical,INIT(translations_directes,TRANSLATIONS_DIRECTES));
/* Indique si l'on doit passer de {X_translate,Y_translate} a {X,Y} ('VRAI') ou l'inverse, */
/* c'est-a-dire passer de {X,Y} a {X_translate,Y_translate} ('FAUX'). */
DEFV(Logical,INIT(avertir_s_il_y_a_redimensionnement,AVERTIR_S_IL_Y_A_REDIMENSIONNEMENT));
/* Indique si l'on doit avertir lorsqu'il y a redimensionnement ('VRAI') ou pas ('FAUX'). */
DEFV(Logical,INIT(methode_de_redimensionnement_a_utiliser_pour_les_images
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER_POUR_LES_IMAGES
)
);
DEFV(Logical,INIT(methode_de_redimensionnement_a_utiliser_pour_les_noyaux
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER_POUR_LES_NOYAUX
)
);
/* Methode de redimensionnement a utiliser si besoin est (introduit le 20210106151223 et */
/* complete le 20210107100532)... */
DEFV(Logical,INIT(avertir_en_presence_d_un_noyau_de_filtrage_non_implicite
,AVERTIR_EN_PRESENCE_D_UN_NOYAU_DE_FILTRAGE_NON_IMPLICITE
)
);
/* Indique si l'on doit avertir lorsque le noyau n'est pas implicite (introduit le */
/* 20060515112945). */
DEFV(Logical,INIT(compatibilite_20030910,COMPATIBILITE_20030910));
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */
/* au 20030910092458. */
DEFV(Logical,INIT(compatibilite_20210106,COMPATIBILITE_20210106));
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */
/* au 20210106151223. */
DEFV(Logical,INIT(compatibilite_20210107,COMPATIBILITE_20210107));
/* Permet de proceder a des filtrages compatibles a ceux qui furent effectues anterieurement */
/* au 20210107100147. */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20030910=",compatibilite_20030910);
GET_ARGUMENT_L("compatibilite_20210106=",compatibilite_20210106);
GET_ARGUMENT_L("compatibilite_20210107=",compatibilite_20210107);
GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("noyauNM=""noyau=""N=""NM=",nom_noyauNM);
GET_ARGUMENT_C("noyauNA=""NA=",nom_noyauNA);
GET_ARGUMENT_C("tX=""imageTX=",nom_image_translation_horizontale);
GET_ARGUMENT_C("tY=""imageTY=",nom_image_translation_verticale);
GET_ARGUMENT_C("imageDX=""dX=",nom_image_deplacement_horizontal);
GET_ARGUMENT_C("imageDY=""dY=",nom_image_deplacement_vertical);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_L("standardA=",les_imagesA_sont_standards);
/* Introduit le 20060307140432... */
GET_ARGUMENT_L("standardN=",les_imagesN_sont_standards);
/* Introduit le 20240812122025... */
GET_ARGUMENT_L("standardR=""standard=",les_imagesR_sont_standards);
/* 'les_images_sont_standards' fut remplace par 'les_imagesR_sont_standards' le */
/* 20060307140022 afin de pouvoir introduire 'les_imagesA_sont_standards'. Au passage, */
/* la logique voudrait que l'on supprime le parametre "standard=" (qui fut donc remplace */
/* a cette date par "standardR="), mais cela impliquerait trop de modifications un peu */
/* partout ; d'ou cette solution de facilite... */
GET_ARGUMENT_L("filtrer=",filtrer);
GET_ARGUMENT_L("editer_extrema=""ee=",editer_les_extrema);
/* Introduit le 20240708081512... */
GET_ARGUMENT_L("etaler=",etaler_le_filtre);
GET_ARGUMENT_I("seuil=""s=",seuil_d_etalement_du_filtre);
GET_ARGUMENT_L("binariser=",binariser_le_filtre);
GIT_ARGUMENT_F("trx=""trX=",translation_OX,_____lNORMALISE_OX(X_TRANSLATION));
GIT_ARGUMENT_F("try=""trY=",translation_OY,_____lNORMALISE_OY(Y_TRANSLATION));
GET_ARGUMENT_L("rn=""renormaliser=",renormaliser_l_image);
GET_ARGUMENT_L("respecter=",respecter_les_extrema_de_l_image_Argument);
GET_ARGUMENT_L("zero=",Ifloat_std_____conserver_le_zero);
GET_ARGUMENT_L("tronquer=",tronquer_les_niveaux);
GET_ARGUMENT_L("directes=""direct=",translations_directes);
GET_ARGUMENT_I("mode=""methode=""mode_image=""methode_image=""mi="
,methode_de_redimensionnement_a_utiliser_pour_les_images
);
GET_ARGUMENT_I("mode_noyau=""methode_noyau=""mn="
,methode_de_redimensionnement_a_utiliser_pour_les_noyaux
);
/* Le parametre "mode=""methode=" a ete introduit le 20210106151223 et complete le */
/* 20210107100532 avec les noyaux... */
GET_ARGUMENT_L("avertir_redimensionnement=",avertir_s_il_y_a_redimensionnement);
GET_ARGUMENT_L("avertir_non_implicite=""ani=",avertir_en_presence_d_un_noyau_de_filtrage_non_implicite);
/* Le parametre "ani=" a ete introduit le 20090801165236... */
)
);
Test(EST_VRAI(les_imagesA_sont_standards))
Bblock
Eblock
ATes
Bblock
Test(EST_VRAI(les_imagesR_sont_standards))
Bblock
PRINT_ERREUR("les options 'standardA=' et 'standardR=' ne sont pas utilisees correctement");
CAL1(Prer2("(l'utilisation de 'standardA=%s' necessite 'standardR=%s' qui est donc force)\n"
,ETAT_LOGIQUE(NEUL(les_imagesA_sont_standards))
,ETAT_LOGIQUE(NOTL(les_imagesR_sont_standards))
)
);
EGAL(les_imagesR_sont_standards,FAUX);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(I4ET(IFEQ(dimX,dimY)
,EST_UNE_PUISSANCE_DE_2(dimX)
,EST_UNE_PUISSANCE_DE_2(dimY)
,IFEQ(pasX,pasY)
)
)
/* Les tests 'EST_UNE_PUISSANCE_DE_2(...)'s furent introduits le 20060313100708... */
/* */
/* Je note le 20170829130321 que ces tests 'EST_UNE_PUISSANCE_DE_2(...)'s ont imposes la */
/* modifications 'v $Fcompilers 20170829120356'... */
Bblock
CALi(Inoir(ImageR));
/* Initialisation de l'image Resultat. ATTENTION, ceci ne peut etre fait comme d'habitude */
/* par : */
/* */
/* CALi(gInettoyage(les_imagesR_sont_standards,ImageR,IFmage_PR)); */
/* */
/* car, en effet, l'initialisation de 'ImageR' a 'NOIR' est imperative, cette valeur etant */
/* utilisee pour initialiser par la suite 'IFmage_PI'... */
Test(EST_VRAI(les_imagesR_sont_standards))
Bblock
/* Cas d'une image 'image' : */
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
CALi(IFinitialisation(IFmage_PR,FZERO));
/* Initialisation de l'image Resultat. */
Eblock
ETes
INITIALISATION_ACCROISSEMENT_2D(translation,translation_OX,translation_OY);
/* Definition de la translation sur le noyau. */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_imagesA_sont_standards,ImageA,IFmageA,nom_imageA))))
Bblock
/* A = image a filtrer. */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_imagesN_sont_standards,ImageA1,IFmageA2,nom_noyauNM))))
Bblock
/* A1 = image definissant le noyau de filtrage Multiplicatif. */
/* */
/* Le 20240812122025 a ete introduite la possibilite que le noyau de filtrage Multiplicatif */
/* ne soit pas standard (il est alors dans 'IFmageA2')... */
#ifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
BDEFV(imageJ,transformee_de_fourier_avant_filtrage);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (avant filtrage). */
BDEFV(imageJ,transformee_de_fourier_apres_filtrage);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Resultat (apres filtrage). */
#Aifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
#Eifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
#ifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_02
# define transformee_de_fourier_avant_filtrage \
IJmageR \
/* Image complexe contenant la transformee de Fourier complexe de l'image */ \
/* Argument (avant filtrage). */
# define transformee_de_fourier_apres_filtrage \
IJmageA \
/* Image complexe contenant la transformee de Fourier complexe de l'image */ \
/* Resultat (apres filtrage). */
#Aifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_02
#Eifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_02
Test(IFNE_chaine(nom_noyauNA,NOM_PIPE))
/* Test introduit le 20240707141548... */
Bblock
CALi(IFinitialisation(IFmageA1,FZERO));
/* A priori... */
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA1,nom_noyauNA))))
Bblock
/* FA1 = image definissant le noyau de filtrage Additif... */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(EST_VRAI(les_imagesR_sont_standards),IL_FAUT(respecter_les_extrema_de_l_image_Argument)))
Bblock
DEFINITION_DU_NOIR_BLANC_DE_ImageA;
/* Positionnement du {NOIR,BLANC} effectif pour le 'Ifloat_std(...)' ulterieur. */
Eblock
ATes
Bblock
Eblock
ETes
Test(EST_VRAI(les_imagesN_sont_standards))
Bblock
Test(IL_FAUT(etaler_le_filtre))
Bblock
#include xci/filtre.04.I"
SET_FILTRAGE(ACTIF);
CALS(Imove(ImageA2,ImageA1));
/* A2 = filtre "etale". */
SET_FILTRAGE(INACTIF);
Eblock
ATes
Bblock
CALS(Imove(ImageA2,ImageA1));
/* A2 = filtre conserve en l'etat... */
Eblock
ETes
Test(IFEQ(Inivo_maximum(ImageA2),NOIR))
Bblock
PRINT_ATTENTION("le filtre 'N' est completement 'NOIR'");
/* Il faut peut-etre agir alors sur 'etaler_le_filtre' et 'seuil_d_etalement_du_filtre'. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(EST_VRAI(les_imagesA_sont_standards))
Bblock
CALS(Istd_float(IFmage_PR,FLOT__NOIR,FLOT__BLANC,ImageA));
CALS(Istd_float(IFmage_PI,FLOT__NOIR,FLOT__BLANC,ImageR));
Eblock
ATes
Bblock
CALS(IFmove(IFmage_PR,IFmageA));
CALi(IFinitialisation(IFmage_PI,FZERO));
/* Possibilite introduite le 20060307140432... */
Eblock
ETes
CALS(Ireelle_complexe(IJmageA,IFmage_PR));
CALS(Iimaginaire_complexe(IJmageA,IFmage_PI));
/* Generation de l'image Argument complexe a transformee avec (ImageA,NOIR) en notant que */
/* ce faisant, la dynamique de 'ImageA' est conservee, la conversion par 'Istd_float(...)' */
/* ayant lieu dans [NOIR,BLANC]. */
CALS(IJfourier_2D_directe_complexe(transformee_de_fourier_avant_filtrage,IJmageA));
/* On fait la transformee directe, */
Test(IFET(IFNE_chaine(nom_image_translation_horizontale,NOM_UNDEF)
,IFNE_chaine(nom_image_translation_verticale,NOM_UNDEF)
)
)
/* ATTENTION, ces deux images doivent etre presentes simultanement pour qu'elles soient */
/* appliquees... */
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA3,nom_image_translation_horizontale))))
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA4,nom_image_translation_verticale))))
Bblock
BDEFV(imageJ,transformee_de_fourier_apres_translation);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (apres translation). */
CALS(IJtranslation_locale_quelconque(transformee_de_fourier_apres_translation
,transformee_de_fourier_avant_filtrage
,ImageA3
,ImageA4
,translations_directes
)
);
/* Et translation quelconque... */
CALS(IJmove(transformee_de_fourier_avant_filtrage,transformee_de_fourier_apres_translation));
/* Et mise en place de la transformee de Fourier apres translation... */
EDEFV(imageJ,transformee_de_fourier_apres_translation);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (apres translation). */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IFNE_chaine(nom_image_deplacement_horizontal,NOM_UNDEF)
,IFNE_chaine(nom_image_deplacement_vertical,NOM_UNDEF)
)
)
/* ATTENTION, ces deux images doivent etre presentes simultanement pour qu'elles soient */
/* appliquees... */
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA3,nom_image_deplacement_horizontal))))
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA4,nom_image_deplacement_vertical))))
Bblock
BDEFV(imageJ,transformee_de_fourier_apres_deplacement);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (apres deplacement). */
CALS(IJdeplacement_local_quelconque(transformee_de_fourier_apres_deplacement
,transformee_de_fourier_avant_filtrage
,ImageA3
,ImageA4
)
);
/* Et translation quelconque... */
CALS(IJmove(transformee_de_fourier_avant_filtrage,transformee_de_fourier_apres_deplacement));
/* Et mise en place de la transformee de Fourier apres translation... */
EDEFV(imageJ,transformee_de_fourier_apres_deplacement);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (apres deplacement). */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(filtrer))
Bblock
Test(EST_VRAI(les_imagesN_sont_standards))
Bblock
CALS(IJfiltrage_multiplicatif(transformee_de_fourier_apres_filtrage
,transformee_de_fourier_avant_filtrage
,ImageA2
,ImageA2
,ADRESSE(translation)
,ADRESSE(translation)
)
);
/* Filtrage par le noyau "etale" Multiplicatif "standard". */
Eblock
ATes
Bblock
CALS(IJFfiltrage_multiplicatif(transformee_de_fourier_apres_filtrage
,transformee_de_fourier_avant_filtrage
,IFmageA2
,IFmageA2
,ADRESSE(translation)
,ADRESSE(translation)
)
);
/* Filtrage par le noyau Multiplicatif "flottant". */
Eblock
ETes
Test(IL_FAUT(editer_les_extrema))
/* Test introduit le 20240708081512... */
Bblock
CAL3(Prme2("MinimumMultiplicatif=(%+.^^^,%+.^^^)\n"
,IJfiltrage_multiplicatif_____minimum_Reelle____
,IJfiltrage_multiplicatif_____minimum_Imaginaire
)
);
CAL3(Prme2("MaximumMultiplicatif=(%+.^^^,%+.^^^)\n"
,IJfiltrage_multiplicatif_____maximum_Reelle____
,IJfiltrage_multiplicatif_____maximum_Imaginaire
)
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE_chaine(nom_noyauNA,NOM_PIPE))
/* Test introduit le 20240707141548... */
Bblock
CALS(IJFfiltrage_additif(transformee_de_fourier_apres_filtrage
,transformee_de_fourier_apres_filtrage
,IFmageA1
,IFmageA1
,ADRESSE(translation)
,ADRESSE(translation)
)
);
/* Filtrage par le noyau Additif. */
Test(IL_FAUT(editer_les_extrema))
/* Test introduit le 20240708081512... */
Bblock
CAL3(Prme2("MinimumAdditif=(%+.^^^,%+.^^^)\n"
,IJFfiltrage_additif_____minimum_Reelle____
,IJFfiltrage_additif_____minimum_Imaginaire
)
);
CAL3(Prme2("MaximumAdditif=(%+.^^^,%+.^^^)\n"
,IJFfiltrage_additif_____maximum_Reelle____
,IJFfiltrage_additif_____maximum_Imaginaire
)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
CALS(IJmove(transformee_de_fourier_apres_filtrage,transformee_de_fourier_avant_filtrage));
/* Pas de filtrage... */
Eblock
ETes
CALS(IJfourier_2D_inverse_complexe(IJmageR,transformee_de_fourier_apres_filtrage));
/* Puis la transformee inverse. */
#include xci/filtre.05.I"
CALi(gIupdate_image(les_imagesR_sont_standards,nom_imageR,ImageR,IFmage_PR));
#ifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
EDEFV(imageJ,transformee_de_fourier_apres_filtrage);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Resultat (apres filtrage). */
EDEFV(imageJ,transformee_de_fourier_avant_filtrage);
/* Image complexe contenant la transformee de Fourier complexe de l'image */
/* Argument (avant filtrage). */
#Aifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
#Eifdef IMPLEMENTATION_DES_TRANSFORMEES_DE_FOURIER_VERSION_01
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test(IFOU(IFOU(IFOU(IFNE_chaine(nom_image_translation_horizontale,NOM_UNDEF)
,IFNE_chaine(nom_image_translation_verticale,NOM_UNDEF)
)
,IFOU(IFNE_chaine(nom_image_deplacement_horizontal,NOM_UNDEF)
,IFNE_chaine(nom_image_deplacement_vertical,NOM_UNDEF)
)
)
,I3OU(IFEQ_chaine(nom_imageA,NOM_PIPE)
,IFEQ_chaine(nom_noyauNM,NOM_PIPE)
,IFEQ_chaine(nom_imageR,NOM_PIPE)
)
)
)
Bblock
PRINT_ERREUR("les images doivent etre carrees (dimX=dimY et pasX=pasY)");
PRINT_ATTENTION("le redimensionnement intermediaire 'Sdu/Squ/Shu' ne peut etre effectue");
/* On notera que par la suite 'Sxu' designe l'un des formats {Sdu,Squ,Shu} correspondant */
/* au format carre et puissance de 2 immediatement superieur au '$formatI' courant... */
PRINT_ATTENTION("et ce pour deux raisons potentielles non exclusives l'une de l'autre :");
PRINT_ATTENTION("1-l'une au moins des options [A=,NM=,R=] reference le 'pipe'");
PRINT_ATTENTION("2-l'une au moins des options [tX=,tY=,dX=,dY=] est presente et reference une image");
/* Lorsque des translations et/ou des deplacements sont demandes, on ne peut tenter le */
/* redimensionnement intermediaire 'Sxu' car c'est trop complique. Il en est de meme */
/* si l'une des images {A,N,R} arrive par le "pipe" ; ceci est evidemment du aux commandes */
/* que l'on va generer ci-apres... */
Eblock
ATes
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageA_Sxu),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_noyauNM_Sxu),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_noyauNA_Sxu),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_gaussNM____),NOM_UNDEF));
DEFV(CHAR,INIC(POINTERc(nom_imageR_Sxu),NOM_UNDEF));
/* Pour pouvoir manipuler des copies 'Sxu' des images {nom_imageR,nom_imageA,nom_noyauNM}. */
DEFV(CHAR,INIC(POINTERc(commande_de_filtrage_Sxu),CHAINE_UNDEF));
/* Definition de la commande filtrage en mode 'Sxu'. */
DEFV(Positive,INIT(nombre_de_coincidences_des_noyaux,ZERO));
/* Nombre de coincidences entre le noyau argument ('ImageA1') et le noyau "implicite" */
/* ('ImageA5'). La valeur initiale ('ZERO') est choisie de facon a ce qu'il n'y ait */
/* a priori pas de coincidences... */
DEFV(Float,INIT(logarithme_en_base_2_de_la_plus_grande_dimension,LO2X(MAX2(dimX,dimY))));
DEFV(Int,INIT(logarithme_entier_en_base_2_de_la_plus_grande_dimension,UNDEF));
Test(EST_ENTIER(logarithme_en_base_2_de_la_plus_grande_dimension))
Bblock
/* Lorsque le logarithme en base 2 de la plus grande dimension est entier, cela signifie */
/* que cette plus grande dimension est deja une puissance de 2... */
Eblock
ATes
Bblock
INCR(logarithme_en_base_2_de_la_plus_grande_dimension,I);
/* Dans le cas contraire, en ajoutant une unite, lors du 'INTE(...)' qui suivra, on */
/* obtiendra la plus petite puissance de 2 immediatement superieure a la plus grande */
/* dimension... */
Eblock
ETes
EGAL(logarithme_entier_en_base_2_de_la_plus_grande_dimension,INTE(logarithme_en_base_2_de_la_plus_grande_dimension));
/* Ainsi, on va obtenir le plus petit carre dont le cote soit une puissance de 2 et qui */
/* englobe le format '$formatI' courant (calcul introduit le 20120906174241). */
Test(IL_FAUT(avertir_s_il_y_a_redimensionnement))
Bblock
PRINT_ATTENTION("un redimensionnement intermediaire 'Sdu/Squ/Shu' va etre effectue automatiquement");
/* Cette fonctionalite a ete introduite le 19990414112509. */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(nom_imageA_Sxu,generation_d_un_nom_absolu_dans_xT_temporaire("A"));
EGAL(nom_noyauNM_Sxu,generation_d_un_nom_absolu_dans_xT_temporaire("NM"));
Test(IFNE_chaine(nom_noyauNA,NOM_PIPE))
/* Test introduit le 20240707141548... */
Bblock
EGAL(nom_noyauNA_Sxu,generation_d_un_nom_absolu_dans_xT_temporaire("NA"));
Eblock
ATes
Bblock
EGAL(nom_noyauNA_Sxu,nom_noyauNA);
Eblock
ETes
EGAL(nom_gaussNM____,generation_d_un_nom_absolu_dans_xT_temporaire("G"));
EGAL(nom_imageR_Sxu,generation_d_un_nom_absolu_dans_xT_temporaire("R"));
/* Creation des noms des copies 'Sxu' des images {nom_imageR,nom_imageA,nom_noyauNM}. */
#define MODE_REDIMENSIONNEMENT_POUR_LES_IMAGES \
COND(EST_VRAI(les_imagesR_sont_standards) \
,COND(IL_FAUT(compatibilite_20030910) \
,REECHANTILLONNAGE_SANS_REECHANTILLONNAGE_AVEC_MISE_AU_CENTRE \
,COND(IL_FAUT(compatibilite_20210106) \
,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE \
,methode_de_redimensionnement_a_utiliser_pour_les_images \
) \
) \
,COND(IL_FAUT(compatibilite_20210106) \
,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE \
,methode_de_redimensionnement_a_utiliser_pour_les_images \
) \
) \
/* Mode a utiliser pour redimensionner les images. */ \
/* */ \
/* ATTENTION : j'ai note le 20030909094922 que le redimensionnement n'etait pas du tout le */ \
/* meme suivant que l'image etait standard ou pas ; si elle n'est pas standard, cette */ \
/* operation lui fait occuper tout l'espace de l'image 'Sxu' alors que si elle est standard, */ \
/* elle va se trouver au centre de l'image 'Sxu' entouree de NOIR. Cela a donc des */ \
/* consequences evidentes sur le resultat ; cela s'est vu lors de la generation de la */ \
/* sequence 'v _____xivPdf_06_2/033309_033436' qui avait utilisee "standard=FAUX" ce qui */ \
/* a donne alors un resultat tres different de 'v $xiia/TREF.21 p=$xiP/fract.02$Fi'. Cette */ \
/* sequence a donc ete regeneree en 'v _____xivPdf_06_2/033437_033564'... */ \
/* */ \
/* Le 20030910101808 il a fallu imposer 'REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE' */ \
/* car, en effet, c'est le seul mode qui existe que les images soient standards ou pas. */ \
/* Or a compter du 20030910092458 le resultat du filtrage au format 'Sxu' est une image */ \
/* qui n'est pas standard ; il convient donc que tous les changement de format se fassent */ \
/* avec le meme mode (et donc 'REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE'...) afin */ \
/* que l'on retombe sur ses pieds (lors du passage au format 'Sxu' et du retour au */ \
/* format original...). */
#define MODE_REDIMENSIONNEMENT_POUR_LES_NOYAUX \
COND(EST_VRAI(les_imagesR_sont_standards) \
,COND(IL_FAUT(compatibilite_20030910) \
,REECHANTILLONNAGE_SANS_REECHANTILLONNAGE_AVEC_MISE_AU_CENTRE \
,COND(IL_FAUT(compatibilite_20210107) \
,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE \
,methode_de_redimensionnement_a_utiliser_pour_les_noyaux \
) \
) \
,COND(IL_FAUT(compatibilite_20210107) \
,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE \
,methode_de_redimensionnement_a_utiliser_pour_les_noyaux \
) \
) \
/* Mode a utiliser pour redimensionner les noyaux (introduit le 20210107100532). En effet */ \
/* les noyaux ne peuvent pas etre redimensionne comme les images sous peine d'introduire */ \
/* des anisotropies (c'est par exemple le cas d'un noyau gaussien qui est parfaitement */ \
/* symetrique et fait de cercles concentriques qui risquaient anterieurement de devenir */ \
/* des ellipses...). */
#define NATURE_DES_IMAGES_A \
ETAT_LOGIQUE(les_imagesA_sont_standards) \
/* Nature des images a filtrer (introduit le 20060307140432)... */
#define NATURE_DES_IMAGES_N \
ETAT_LOGIQUE(les_imagesN_sont_standards) \
/* Nature des noyaux (introduit le 20240812122025)... */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten13
(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"format.01")
," A=",nom_imageA
," standard=",NATURE_DES_IMAGES_A
," MdefRedim=",C_FAUX____
," mode=",chain_Aentier(MODE_REDIMENSIONNEMENT_POUR_LES_IMAGES)
," R=",nom_imageA_Sxu
,GENERATION_DE_formatI
,GENERATION_DE_formatR_Sxu
)
);
/* Redimensionnement au format 'Sxu' de l'image Argument. */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten6(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"gauss")
," standard=",NATURE_DES_IMAGES_N
," R=",nom_gaussNM____
,GENERATION_DE_formatI
)
);
/* Generation d'un noyau de filtrage avec les options implicites de '$xci/gauss$X' et */
/* avec la dimension definie par '$formatI'. */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_imagesN_sont_standards,ImageA1,IFmageA2,nom_noyauNM))))
Bblock
/* A1 = image definissant le noyau de filtrage. */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_imagesN_sont_standards,ImageA5,IFmageA3,nom_gaussNM____))))
Bblock
/* A5 = noyau de filtrage "implicite". */
EGAL(nombre_de_coincidences_des_noyaux
,gIcomptage_des_coincidences(les_imagesN_sont_standards,ImageA1,IFmageA2,ImageA5,IFmageA3)
);
/* En comptant les coincidences entre le noyau argument ('ImageA1') et le noyau "implicite" */
/* ('ImageA5'), il est possible de savoir si le noyau argument a ete genere de facon */
/* "implicite" par '$xci/gauss$X'... */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Test(IFNE(nombre_de_coincidences_des_noyaux,dimXY))
Bblock
/* Cas ou le noyau argument ('ImageA1') n'a pas ete genere de facon "implicite" par */
/* '$xci/gauss$X', on ne peut que redimensionner "betement" le noyau argument : */
Test(IL_FAUT(avertir_en_presence_d_un_noyau_de_filtrage_non_implicite))
Bblock
/* Test introduit le 20060515112945... */
PRINT_ATTENTION("le noyau de filtrage n'est pas 'implicite', il va etre redimensionne 'brutalement'");
/* Cette fonctionalite a ete introduite le 19990427092629. Le "brutalement" signifie que */
/* l'on rajoute du 'NOIR' autour pour obtenir la dimension 'Sxu'... */
Eblock
ATes
Bblock
Eblock
ETes
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten13
(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"format.01")
," A=",nom_noyauNM
," standard=",NATURE_DES_IMAGES_N
," MdefRedim=",C_FAUX____
," mode=",chain_Aentier(MODE_REDIMENSIONNEMENT_POUR_LES_NOYAUX)
," R=",nom_noyauNM_Sxu
,GENERATION_DE_formatI
,GENERATION_DE_formatR_Sxu
)
);
/* Redimensionnement au format 'Sxu' de l'image Noyau M. ATTENTION, evidemment le noyau */
/* utilise en mode 'Sxu' correspond au Noyau argument avec du 'NOIR' autour... */
Eblock
ATes
Bblock
/* Cas ou le noyau argument ('ImageA1') a ete genere de facon "implicite" par */
/* '$xci/gauss$X', on peut donc le regenerer de facon "implicite" en mode 'Sxu' : */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten6(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"gauss")
," standard=",NATURE_DES_IMAGES_N
," R=",nom_noyauNM_Sxu
,GENERATION_DE_formatI_Sxu
)
);
/* Generation du noyau de filtrage correspondant au noyau argument en mode 'Sxu'... */
Eblock
ETes
Test(IFNE_chaine(nom_noyauNA,NOM_PIPE))
/* Test introduit le 20240707141548... */
Bblock
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten13
(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"format.01")
," A=",nom_noyauNA
," standard=",C_FAUX____
," MdefRedim=",C_FAUX____
," mode=",chain_Aentier(MODE_REDIMENSIONNEMENT_POUR_LES_NOYAUX)
," R=",nom_noyauNA_Sxu
,GENERATION_DE_formatI
,GENERATION_DE_formatR_Sxu
)
);
/* Redimensionnement au format 'Sxu' de l'image Noyau A. */
Eblock
ATes
Bblock
Eblock
ETes
RECONSTITUTION_DE_LA_COMMANDE_COURANTE(commande_de_filtrage_Sxu);
/* Recuperation de la commande de filtrage courante. On notera que l'on recopie donc en */
/* particulier les arguments : */
/* */
/* A=... */
/* N=... */
/* R=... */
/* $formatI */
/* */
/* mais que ces valeurs seront ulterieurement ignorees, car, ci-apres, vont etre rajoutees */
/* derriere la chaine courante 'commande_de_filtrage_Sxu' les veritables arguments */
/* {nom_imageA_Sxu,nom_noyauNM_Sxu,nom_imageR_Sxu,format_Sxu} a utiliser lors du filtrage */
/* 'Sxu'. Malheureusement, cela n'implique pas que l'un de ces arguments puisse referencer */
/* 'NOM_PIPE' ; en effet, le redimensionnement au format 'Sxu' de l'image Noyau, lorsqu'il */
/* necessaire, l'interdit... */
#define NATURE_DES_IMAGES_R \
ETAT_LOGIQUE(COND(IL_FAUT(compatibilite_20030910),les_imagesR_sont_standards,FAUX)) \
/* Nature des images a generer (introduit le 20030910092458)... */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten16(commande_de_filtrage_Sxu
," A=",nom_imageA_Sxu
," NM=",nom_noyauNM_Sxu
," NA=",nom_noyauNA_Sxu
," standardA=",NATURE_DES_IMAGES_A
," standardN=",NATURE_DES_IMAGES_N
," standardR=",NATURE_DES_IMAGES_R
," R=",nom_imageR_Sxu
,GENERATION_DE_formatI_Sxu
)
);
/* Execution de la commande de filtrage en mode 'Sxu' avec les arguments temporaires 'Sxu'. */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten14
(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"format.01")
," A=",nom_imageR_Sxu
," standard=",NATURE_DES_IMAGES_R
," MdefRedim=",C_FAUX____
," mode=",chain_Aentier(MODE_REDIMENSIONNEMENT_POUR_LES_IMAGES)
," R=",nom_imageR
,GENERATION_DE_formatI_Sxu
,GENERATION_DE_formatR,GENERATION_DE_PasX_PasY_TraX_TraY
)
);
/* Remise au format demande de l'image Resultat. */
#undef NATURE_DES_IMAGES_R
#undef NATURE_DES_IMAGES_A
Test(IL_FAUT(compatibilite_20030910))
Bblock
Eblock
ATes
Bblock
/* Le 20030910092458 il a ete decide de conserve le resultat du filtrage 'Sxu' precedent */
/* sous forme d'une image non standard et de la redimensionner dans ce format a l'aide */
/* du mode 'REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE'. Ceci permet de garantir une */
/* gestion correcte des extrema des niveaux de l'image Resultat... Anterieurement a cette */
/* date, avec les arguments implicites, les niveaux d'une image Resultat de format non */
/* carre n'utilisaient pas tout le segment [NOIR,BLANC]. Au passage, cela a simultanement */
/* attenue (voire fait disparaitre...) les effets de bord... */
#define NATURE_DES_IMAGES_R \
ETAT_LOGIQUE(les_imagesR_sont_standards)
#define ZERO_DES_IMAGES \
ETAT_LOGIQUE(Ifloat_std_____conserver_le_zero)
/* Uniquement afin de raccorcir certaines lignes suivantes... */
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(chain_Aconcaten15
(GENERATION_NOM_D_UNE_COMMANDE_X(Direct_xci,"acces")
," A=",nom_imageR
," standard=",C_FAUX____
," convertir_non_standard=",NATURE_DES_IMAGES_R
," extrema=",C_VRAI____
," zero=",ZERO_DES_IMAGES
," R=",nom_imageR
,GENERATION_DE_formatI,GENERATION_DE_PasX_PasY_TraX_TraY
)
);
/* Enfin, conversion eventuelle... */
#undef ZERO_DES_IMAGES
#undef NATURE_DES_IMAGES_R
Eblock
ETes
CALZ_FreCC(commande_de_filtrage_Sxu);
Test(IFET(EST_VRAI(les_imagesR_sont_standards),IL_FAUT(respecter_les_extrema_de_l_image_Argument)))
Bblock
Test(IFNE_chaine(nom_imageA,nom_imageR))
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageA))))
Bblock
/* A = image a filtrer. */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageR,nom_imageR))))
Bblock
/* R = image filtree (et oui, le 20020107123233, il a fallu introduire cette mise a jour */
/* de 'ImageR' qui vient d'etre calculee via un redimensionnement 'Sxu' lorsque le respect */
/* des extrema de 'ImageA' a ete demande... */
BDEFV(imageF,image_flottante);
/* Image flottante dans laquelle on trouve l'image a renormaliser. */
DEFINITION_DU_NOIR_BLANC_DE_ImageA;
/* Positionnement du {NOIR,BLANC} effectif pour le 'Ifloat_std_avec_renormalisation(...)' */
/* qui va suivre... */
CALS(Irenormalisation(ImageR,ImageR));
/* Lorsque 'IL_FAUT(respecter_les_extrema_de_l_image_Argument)' et qu'il y a eu (ci-avant) */
/* un redimensionnement, le respect des extrema de 'ImageA' a eu lieu dans une image au */
/* format 'Sxu'. Lors du redimensionnement de retour au format courant, l'image 'ImageR' */
/* extraite a bien peu de chance de conserver ce respect (en particulier, les extrema */
/* pouvaient tres bien etre en dehors de l'image 'ImageR' redimensionnee puisqu'elle est */
/* plus petite que l'image 'Sxu'...). */
CALi(Iupdate_image(nom_imageR,ImageR));
/* Et mise a jour de 'ImageR'... */
EDEFV(imageF,image_flottante);
/* Image flottante dans laquelle on trouve l'image a renormaliser. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le respect des niveaux de l'image Argument ne peut avoir lieu");
PRINT_ERREUR("(les noms des images Argument et Resultat sont identiques)");
/* En effet, etant donne qu'on doit relire 'ImageA' et 'ImageR', puis utiliser 'ImageA' */
/* pour renormaliser 'ImageR', si les deux images sont identiques, il y a probleme... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
#undef MODE_REDIMENSIONNEMENT_POUR_LES_IMAGES
CALS(Idelete_image(nom_imageA_Sxu));
CALZ_FreCC(nom_imageA_Sxu);
Test(IFNE_chaine(nom_noyauNA,NOM_PIPE))
/* Test introduit le 20240708112313... */
Bblock
CALS(Idelete_image(nom_noyauNA_Sxu));
CALZ_FreCC(nom_noyauNA_Sxu);
Eblock
ATes
Bblock
Eblock
ETes
CALS(Idelete_image(nom_noyauNM_Sxu));
CALZ_FreCC(nom_noyauNM_Sxu);
CALS(Idelete_image(nom_gaussNM____));
CALZ_FreCC(nom_gaussNM____);
CALS(Idelete_image(nom_imageR_Sxu));
CALZ_FreCC(nom_imageR_Sxu);
/* Nettoyage... */
Eblock
ETes
Eblock
ETes
RETU_Commande;
Eblock
ECommande