_______________________________________________________________________________________________________________________________________
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S : */
/* */
/* */
/* Definition : */
/* */
/* Dans ce fichier se trouvent toutes */
/* les fonctions necessaires a la trans- */
/* formee en ondelettes. */
/* */
/* */
/* Cas mono-dimensionnel : */
/* --------------------- */
/* */
/* Soit une fonction "discrete" 'f' */
/* connue aux points (Xmin,...,Xmax), */
/* ce qui signifie que l'on connait les */
/* valeurs (f(Xmin),...,f(Xmax)). */
/* Designons par T(f) la transformee en */
/* ondelettes "discrete" de la fonction 'f'. */
/* */
/* Soit g(t) l'ondelette, ou 't' designe */
/* une variable continue; g(t) est en */
/* general une fonction a valeur complexe, */
/* mais sera supposee ici reelle afin de */
/* simplifier la programmation... */
/* */
/* La transformee en ondelette de f(u) */
/* par rapport a l'ondelette g(t) est */
/* definie au point (b,a) par : */
/* */
/* */
/* X=Xmax */
/* ___ */
/* \ 1 X-b */
/* T(f,(b,a)) = / ---.g(-----).f(X) ou 'b' est le parametre de position et 'a' le parametre d'echelle. */
/* --- a a */
/* X=Xmin */
/* */
/* L'algorithme qui suit fait l'hypothese */
/* que g(t) peut s'exprimer localement par un */
/* polynome de degre 3, plus exactement on */
/* ecrit que : */
/* */
/* 0 1 2 3 */
/* g(X + t) = C .t + C .t + C .t + C .t pour X E [nL,nR] ('X' entier), et t E [0,1[, */
/* X,0 X,1 X,2 X,3 */
/* */
/* g(t) = 0 pour t < 0 et t >= 1. */
/* */
/* */
/* Description de l'algorithme de Matthias Holschneider : */
/* ---------------------------------------------------- */
/* */
/* Soit : */
/* */
/* X=m */
/* ___ */
/* \ 0 */
/* S (m) = / X . f(X) */
/* 0 --- */
/* X=Xmin */
/* */
/* X=m */
/* ___ */
/* \ 1 */
/* S (m) = / X . f(X) */
/* 1 --- */
/* X=Xmin */
/* */
/* X=m */
/* ___ */
/* \ 2 */
/* S (m) = / X . f(X) */
/* 2 --- */
/* X=Xmin */
/* */
/* X=m */
/* ___ */
/* \ 3 */
/* S (m) = / X . f(X) */
/* 3 --- */
/* X=Xmin */
/* */
/* */
/* avec les conventions "limite" suivantes : */
/* */
/* */
/* S (m) = 0 si m<Xmin, */
/* i */
/* = S (Xmax) si m>Xmax. */
/* i */
/* */
/* */
/* On montre alors "aisement" que T(f,(b,a)) peut s'ecrire : */
/* */
/* X=nR */
/* ____ 0 1 2 3 */
/* \ B B B B */
/* T(f,(b,a)) = / {S [b + (X+1).a - 1] - S [b + (X).a - 1]} . {C .--- - C .--- + C .--- - C .---} + */
/* ---- 0 0 X,0 0 X,1 1 X,2 2 X,3 3 */
/* X=nL a a a a */
/* */
/* X=nR */
/* ____ 0 1 2 */
/* \ B B B */
/* / {S [b + (X+1).a - 1] - S [b + (X).a - 1]} . {C .--- - 2.C .--- + 3.C .---} + */
/* ---- 1 1 X,1 1 X,2 2 X,3 3 */
/* X=nL a a a */
/* */
/* X=nR */
/* ____ 0 1 */
/* \ B B */
/* / {S [b + (X+1).a - 1] - S [b + (X).a - 1]} . {C .--- - 3.C .---} + */
/* ---- 2 2 X,2 2 X,3 3 */
/* X=nL a a */
/* */
/* X=nR */
/* ____ 0 */
/* \ B */
/* / {S [b + (X+1).a - 1] - S [b + (X).a - 1]} . {C .---} */
/* ---- 3 3 X,3 3 */
/* X=nL a */
/* */
/* */
/* avec 'a' entier, et en posant : */
/* */
/* B = b + X.a */
/* */
/* */
/* Cas bi-dimensionnel : */
/* ------------------- */
/* */
/* Soit une fonction "discrete" 'f' */
/* connue aux points ((Xmin,Ymin),...,(Xmax,Ymax)) */
/* ce qui signifie que l'on connait les */
/* valeurs (f(Xmin,Ymin),...,f(Xmax,Ymax)) */
/* Designons par T(f) la transformee en */
/* ondelettes "discrete" de la fonction 'f'. */
/* */
/* Soit g(t) l'ondelette, ou 't' designe */
/* une variable continue; g(t) est en */
/* general une fonction a valeur complexe, */
/* mais sera supposee ici reelle afin de */
/* simplifier la programmation... */
/* */
/* La transformee en ondelette de f(u) */
/* par rapport a l'ondelette g(t) est */
/* definie au point (b,a) par : */
/* */
/* */
/* Y=Ymax X=Xmax */
/* ___ ___ X-b Y-b */
/* \ \ 1 x y */
/* T(f,(b,a)) = / / -------.g(------,------).f(X,Y) */
/* --- --- a .a a a */
/* Y=Ymin X=Xmin x y x y */
/* */
/* ou 'b' est le vecteur-parametre de position et 'a' le vecteur-parametre d'echelle. */
/* */
/* */
/* Author of '$ximt/ondelettes$FON' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 19890000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S V E R S I O N S : */
/* */
/*************************************************************************************************************************************/
#ifdef FONCTION_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
DEFV(Common,DEFV(Logical,_____FONCTION_ONDELETTE_1D_VERSION_01));
#Aifdef FONCTION_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#Eifdef FONCTION_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#ifdef FONCTION_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
DEFV(Common,DEFV(Logical,_____FONCTION_ONDELETTE_1D_VERSION_02));
#Aifdef FONCTION_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
#Eifdef FONCTION_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
#ifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
DEFV(Common,DEFV(Logical,_____CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_01));
#Aifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#Eifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#ifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
DEFV(Common,DEFV(Logical,_____CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_02));
#Aifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
#Eifdef CHOIX_DE_LA_METHODE_D_APPROXIMATION_DE_L_ONDELETTE_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
#ifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
DEFV(Common,DEFV(Logical,_____APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_01));
#Aifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#Eifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
#ifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
DEFV(Common,DEFV(Logical,_____APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_02));
#Aifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
#Eifdef APPROXIMEE_PARFAITE_ONDELETTE_1D_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' O N D E L E T T E D E M O R L E T M O N O - D I M E N S I O N N E L L E : */
/* */
/* */
/* Definition : */
/* */
/* L'ondelette de Morlet est definie */
/* en complexe par : */
/* */
/* 2 */
/* X */
/* - --- */
/* 2 */
/* e .[cos(F .X) + i.sin(F .X)] */
/* r i */
/* */
/* ou 'F ' et 'F ' designent respectivement */
/* r i */
/* les frequences 'reelle' et 'imaginaire'. */
/* */
/* */
/*************************************************************************************************************************************/
#define FREQUENCES_REELLE_ET_IMAGINAIRE \
FREQUENCE_DE_L_ONDELETTE \
/* Valeur initiale (et implicite) des frequences reelle et imaginaire de l'ondelette */ \
/* de Morlet. */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____frequence_reelle,FREQUENCES_REELLE_ET_IMAGINAIRE)));
/* Definition de la frequence de calcul de la partie reelle de l'ondelette de Morlet, */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____frequence_imaginaire,FREQUENCES_REELLE_ET_IMAGINAIRE)));
/* Definition de la frequence de calcul de la partie imaginaire de l'ondelette de Morlet. */
#undef FREQUENCES_REELLE_ET_IMAGINAIRE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R T I E R E E L L E D E L ' O N D E L E T T E D E M O R L E T */
/* M O N O - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fpartie_reelle_de_l_ondelette_1D_de_Morlet(variable)))
DEFV(Argument,DEFV(Float,variable));
/* Valeur de la variable. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(partie_reelle,ONDELETTE_1D_DE_MORLET_PARTIE_REELLE(variable)));
/* On renvoie la partie reelle. */
/*..............................................................................................................................*/
RETU(partie_reelle);
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R T I E I M A G I N A I R E D E L ' O N D E L E T T E D E M O R L E T : */
/* M O N O - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fpartie_imaginaire_de_l_ondelette_1D_de_Morlet(variable)))
DEFV(Argument,DEFV(Float,variable));
/* Valeur de la variable. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(partie_imaginaire,ONDELETTE_1D_DE_MORLET_PARTIE_IMAGINAIRE(variable)));
/* On renvoie la partie imaginaire. */
/*..............................................................................................................................*/
RETU(partie_imaginaire);
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' O N D E L E T T E D E M O R L E T */
/* M O N O - D I M E N S I O N N E L L E A P P R O C H E E : */
/* */
/* */
/* Definition : */
/* */
/* L'ondelette de Morlet est definie */
/* en complexe par : */
/* */
/* 2 */
/* X */
/* - --- */
/* 2 */
/* e .[cos(F .X) + i.sin(F .X)] */
/* r i */
/* */
/* ou 'F ' et 'F ' designent respectivement */
/* r i */
/* les frequences 'reelle' et 'imaginaire', */
/* et ou on developpe en serie entiere les */
/* fonctions, soit : */
/* */
/* 2 2 4 */
/* - 3 - F 15 + 10.F + F */
/* 2 r 2 r r */
/* F .X.[1 + X .(---------- + X .-----------------)] */
/* r 6 120 */
/* */
/* et : */
/* */
/* 2 2 4 */
/* - 1 - F 3 + 6.F + F */
/* 2 i 2 i i */
/* 1 + X .(---------- + X .---------------) */
/* 2 24 */
/* */
/* */
/*************************************************************************************************************************************/
#define FREQUENCES_REELLE_ET_IMAGINAIRE \
FREQUENCE_DE_L_ONDELETTE \
/* Valeur initiale (et implicite) des frequences reelle et imaginaire de l'ondelette */ \
/* de Morlet. */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____approximation_frequence_reelle,FREQUENCES_REELLE_ET_IMAGINAIRE)));
/* Definition de la frequence de calcul de la partie reelle de l'ondelette de Morlet, */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____approximation_frequence_imaginaire,FREQUENCES_REELLE_ET_IMAGINAIRE)));
/* Definition de la frequence de calcul de la partie imaginaire de l'ondelette de Morlet. */
#undef FREQUENCES_REELLE_ET_IMAGINAIRE
DEFV(Local,DEFV(Float,INIT(Fondelettes_1D_____frequence_reelle_courante,FLOT__UNDEF)));
/* Definition de la frequence courante de la partie reelle de l'ondelette de Morlet, */
DEFV(Local,DEFV(Float,INIT(coefficient_courant_R3,FLOT__UNDEF)));
/* Coefficient du troisieme degre de la partie reelle, soit : */
/* */
/* 2 */
/* - 3 - F */
/* r */
/* ---------- */
/* 6 */
/* */
DEFV(Local,DEFV(Float,INIT(coefficient_courant_R5,FLOT__UNDEF)));
/* Coefficient du cinquieme degre de la partie reelle, soit : */
/* */
/* 2 4 */
/* 15 + 10.F + F */
/* r r */
/* ----------------- */
/* 120 */
/* */
DEFV(Local,DEFV(Float,INIT(Fondelettes_1D_____frequence_imaginaire_courante,FLOT__UNDEF)));
/* Definition de la frequence courante de la partie imaginaire de l'ondelette de Morlet. */
DEFV(Local,DEFV(Float,INIT(coefficient_courant_I2,FLOT__UNDEF)));
/* Coefficient du deuxieme degre de la partie imaginaire, soit : */
/* */
/* 2 */
/* - 1 - F */
/* i */
/* ---------- */
/* 2 */
/* */
DEFV(Local,DEFV(Float,INIT(coefficient_courant_I4,FLOT__UNDEF)));
/* Coefficient du quatrieme degre de la partie imaginaire, soit : */
/* */
/* 2 4 */
/* 3 + 6.F + F */
/* i i */
/* --------------- */
/* 24 */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R T I E R E E L L E D E L ' O N D E L E T T E D E M O R L E T */
/* M O N O - D I M E N S I O N N E L L E A P P R O C H E E : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fpartie_reelleA_de_l_ondelette_1D_de_Morlet(variable)))
DEFV(Argument,DEFV(Float,variable));
/* Valeur de la variable. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(partie_reelle,FLOT__UNDEF));
/* On renvoie la partie reelle. */
/*..............................................................................................................................*/
Test(IFNE(Fondelettes_1D_____frequence_reelle_courante,Fondelettes_1D_____approximation_frequence_reelle))
Bblock
EGAL(Fondelettes_1D_____frequence_reelle_courante,Fondelettes_1D_____approximation_frequence_reelle);
/* Definition de la frequence courante de la partie reelle de l'ondelette de Morlet, */
EGAL(coefficient_courant_R3
,DIVI(NEGA(ADD2(FLOT(TROIS),EXP2(Fondelettes_1D_____frequence_reelle_courante)))
,FLOT(MUL2(TROIS,MUL2(DEUX,UN)))
)
);
/* Coefficient du troisieme degre de la partie reelle, soit : */
/* */
/* 2 */
/* - 3 - F */
/* r */
/* ---------- */
/* 6 */
/* */
EGAL(coefficient_courant_R5
,DIVI(ADD3(FLOT(QUINZE)
,MUL2(FLOT(DIX),EXP2(Fondelettes_1D_____frequence_reelle_courante))
,EXP4(Fondelettes_1D_____frequence_reelle_courante)
)
,FLOT(MUL2(CINQ,MUL2(QUATRE,MUL2(TROIS,MUL2(DEUX,UN)))))
)
);
/* Coefficient du cinquieme degre de la partie reelle, soit : */
/* */
/* 2 4 */
/* 15 + 10.F + F */
/* r r */
/* ----------------- */
/* 120 */
/* */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(partie_reelle
,MUL2(AXPB(AXPB(coefficient_courant_R5
,EXP2(variable)
,coefficient_courant_R3
)
,EXP2(variable)
,FU
)
,MUL2(Fondelettes_1D_____frequence_reelle_courante,variable)
)
);
RETU(partie_reelle);
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R T I E I M A G I N A I R E D E L ' O N D E L E T T E D E M O R L E T */
/* M O N O - D I M E N S I O N N E L L E A P P R O C H E E : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fpartie_imaginaireA_de_l_ondelette_1D_de_Morlet(variable)))
DEFV(Argument,DEFV(Float,variable));
/* Valeur de la variable. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(partie_imaginaire,FLOT__UNDEF));
/* On renvoie la partie imaginaire. */
/*..............................................................................................................................*/
Test(IFNE(Fondelettes_1D_____frequence_imaginaire_courante
,Fondelettes_1D_____approximation_frequence_imaginaire
)
)
Bblock
EGAL(Fondelettes_1D_____frequence_imaginaire_courante
,Fondelettes_1D_____approximation_frequence_imaginaire
);
/* Definition de la frequence courante de la partie imaginaire de l'ondelette de Morlet. */
EGAL(coefficient_courant_I2
,DIVI(NEGA(ADD2(FU,EXP2(Fondelettes_1D_____frequence_imaginaire_courante)))
,FLOT(MUL2(DEUX,UN))
)
);
/* Coefficient du deuxieme degre de la partie imaginaire, soit : */
/* */
/* 2 */
/* - 1 - F */
/* i */
/* ---------- */
/* 2 */
/* */
EGAL(coefficient_courant_I4
,DIVI(ADD3(FLOT(TROIS)
,MUL2(FLOT(SIX),EXP2(Fondelettes_1D_____frequence_imaginaire_courante))
,EXP4(Fondelettes_1D_____frequence_imaginaire_courante)
)
,FLOT(MUL2(QUATRE,MUL2(TROIS,MUL2(DEUX,UN))))
)
);
/* Coefficient du quatrieme degre de la partie imaginaire, soit : */
/* */
/* 2 4 */
/* 3 + 6.F + F */
/* i i */
/* --------------- */
/* 24 */
/* */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(partie_imaginaire
,AXPB(AXPB(coefficient_courant_I4
,EXP2(variable)
,coefficient_courant_I2
)
,EXP2(variable)
,FU
)
);
RETU(partie_imaginaire);
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S M O N O - D I M E N S I O N N E L L E */
/* R E E L L E E T N O N A P P R O X I M E E ( O U " P A R F A I T E " ) : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fondelettes_1D_reelles_parfaites(fonction
,ARGUMENT_POINTERs(parametre_de_position_1D)
,ARGUMENT_POINTERs(parametre_d_echelle_1D)
,ARGUMENT_FONCTION(ondelette)
)
)
)
DEFV(Argument,DEFV(ligneD,fonction));
/* Vecteur contenant la fonction discrete argument. */
DEFV(Argument,DEFV(pointF_1D,POINTERs(parametre_de_position_1D)));
/* Parametre de position ('b') qui est dans [0,1], et qui apres '_cDENORMALISE_OX()' */
/* sera un nombre entier... */
DEFV(Argument,DEFV(coeffF_1D,POINTERs(parametre_d_echelle_1D)));
/* Parametre d'echelle ('a'). */
DEFV(Argument,DEFV(Float,afPOINTEUR(ondelette)));
/* Definition de l'ondelette (par exemple, celle de Morlet -parties reelle et imaginaire-). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(pointD_1D,coordonnees_de_l_ondelette);
/* Coordonnee obtenue a partir de 'X', en tant que coordonnee de l'ondelette. */
DEFV(Double,INIT(cumul_courant,FZERO));
/* Cumul courant donnant a la derniere etape ('INDEX_DE_DROITE_DE_L_ONDELETTE_1D') */
/* la valeur de la transformee de la fonction en (b,a). */
/*..............................................................................................................................*/
Test(IZLE(ASI1(parametre_d_echelle_1D,cx)))
Bblock
PRINT_ERREUR("le facteur d'echelle est negatif ou nul");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGE(INDEX_DE_GAUCHE_DE_L_ONDELETTE_1D,INDEX_DE_DROITE_DE_L_ONDELETTE_1D))
Bblock
PRINT_ERREUR("la definition des indices de l'ondelette est mauvaise");
Eblock
ATes
Bblock
Eblock
ETes
begin_ligne
Bblock
INITIALISATION_POINT_1D(coordonnees_de_l_ondelette
,DIVI(DPRE(SOUS(FLOT(X),F__cDENORMALISE_OX(ASI1(parametre_de_position_1D,x))))
,DPRE(ASI1(parametre_d_echelle_1D,cx))
)
);
/* Calcul de la coordonnee d'acces a l'ondelette : */
/* */
/* X-b */
/* ----- */
/* a */
/* */
Test(INCLff(ASD1(coordonnees_de_l_ondelette,x)
,DPRE(INDEX_DE_GAUCHE_DE_L_ONDELETTE_1D)
,DPRE(INDEX_DE_DROITE_DE_L_ONDELETTE_1D)
)
)
Bblock
INCR(cumul_courant
,MUL2(fPOINTEUR(ondelette)(ASD1(coordonnees_de_l_ondelette,x))
,LIGNE(fonction,X,Ymin)
)
);
/* Iteration de calcul du produit de convolution entre la fonction et l'ondelette : */
/* */
/* X=Xmax */
/* ___ */
/* \ 1 X-b */
/* T(f,(b,a)) = / ---.g(-----).f(X) */
/* --- a a */
/* X=Xmin */
/* */
/* ou encore : */
/* */
/* X=Xmax */
/* ___ */
/* 1 \ X-b */
/* T(f,(b,a)) = ---./ g(-----).f(X) */
/* a --- a */
/* X=Xmin */
/* */
/* ou 'b' est le parametre de position et 'a' le parametre d'echelle. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_ligne
RETU(DIVI(cumul_courant,ASI1(parametre_d_echelle_1D,cx)));
/* Renvoi de la valeur reelle de la transformee cherchee... */
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O N D E L E T T E D E M O R L E T B I - D I M E N S I O N N E L L E : */
/* */
/* */
/* Definition : */
/* */
/* Un champ dit "de Morlet" est defini par */
/* l'equation : */
/* */
/* 2 2 */
/* X + Y */
/* - --------- */
/* 2 i.(|k|.cos(t).X + |k|.sin(t).Y) */
/* F(X,Y) = e .e */
/* */
/* ou : */
/* */
/* X */
/* X = --- */
/* a */
/* */
/* et : */
/* */
/* Y */
/* Y = --- */
/* a */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____dilatation_ondelette_2D_de_Morlet,FU)));
/* Coefficient de dilatation des coordonnees. */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____phase_ondelette_2D_de_Morlet,FZERO)));
/* Angle 't' dans l'equation ci-dessus. */
DEFV(Common,DEFV(Float,ZINT(Fondelettes_1D_____module_ondelette_2D_de_Morlet,FU)));
/* Module |k| dans l'equation ci-dessus. */
DEFV(Local,DEFV(Float,INIT(Fondelettes_1D_____phase_ondelette_2D_de_Morlet_courante,FLOT__UNDEF)));
/* Valeur courante de l'angle 't' dans l'equation ci-dessus ; celle-ci permet de savoir */
/* si les produits |k|.cos(t) et |k|.sin(t) ont ete initialises. */
DEFV(Local,DEFV(Float,INIT(kcost_ondelette_2D_de_Morlet_courant,FLOT__UNDEF)));
/* Valeur courante du produit |k|.cos(t), */
DEFV(Local,DEFV(Float,INIT(ksint_ondelette_2D_de_Morlet_courant,FLOT__UNDEF)));
/* Valeur courante du produit |k|.sin(t). */
#define DONNEES_DE_CALCUL_DE_L_ONDELETTE_DE_MORLET_2D \
DEFV(Float,INIT(Xf_dilate,DIVI(Xf,Fondelettes_1D_____dilatation_ondelette_2D_de_Morlet))); \
/* Abscisse dilatee, */ \
DEFV(Float,INIT(Yf_dilate,DIVI(Yf,Fondelettes_1D_____dilatation_ondelette_2D_de_Morlet))); \
/* Ordonnee dilatee, */ \
DEFV(Float,INIT(fxy,FLOT__UNDEF)); \
/* Valeur de la fonction 'Fxy' pour un champ Morlet. */
#define ACCELERATION_ONDELETTE_DE_MORLET_2D \
Bblock \
Test(IFNE(Fondelettes_1D_____phase_ondelette_2D_de_Morlet_courante \
,Fondelettes_1D_____phase_ondelette_2D_de_Morlet \
) \
) \
Bblock \
EGAL(kcost_ondelette_2D_de_Morlet_courant \
,MUL2(Fondelettes_1D_____module_ondelette_2D_de_Morlet \
,COSX(Fondelettes_1D_____phase_ondelette_2D_de_Morlet) \
) \
); \
/* Valeur courante du produit |k|.cos(t), */ \
EGAL(ksint_ondelette_2D_de_Morlet_courant \
,MUL2(Fondelettes_1D_____module_ondelette_2D_de_Morlet \
,SINX(Fondelettes_1D_____phase_ondelette_2D_de_Morlet) \
) \
); \
/* Valeur courante du produit |k|.sin(t). */ \
EGAL(Fondelettes_1D_____phase_ondelette_2D_de_Morlet_courante \
,Fondelettes_1D_____phase_ondelette_2D_de_Morlet \
); \
/* Valeur courante de l'angle 't' dans l'equation ci-dessus ; celle-ci permet de savoir */ \
/* si les produits |k|.cos(t) et |k|.sin(t) ont ete initialises. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Permet d'eviter le recalcul systematique de |k|.cos(t) et |k|.sin(t). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O N D E L E T T E D E M O R L E T P A R T I E R E E L L E B I - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,Fpartie_reelle_de_l_ondelette_2D_de_Morlet(Xf,Yf)))
DEFV(Argument,DEFV(Float,Xf));
DEFV(Argument,DEFV(Float,Yf));
/* Coordonnees flottantes 'Xf' et 'Yf' dans [0,1[. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DONNEES_DE_CALCUL_DE_L_ONDELETTE_DE_MORLET_2D
/*..............................................................................................................................*/
ACCELERATION_ONDELETTE_DE_MORLET_2D;
EGAL(fxy
,MUL2(EXPB(NEGA(MOIT(ADD2(EXP2(Xf_dilate),EXP2(Yf_dilate))
)
)
)
,COSX(ADD2(MUL2(kcost_ondelette_2D_de_Morlet_courant,Xf_dilate)
,MUL2(ksint_ondelette_2D_de_Morlet_courant,Yf_dilate)
)
)
)
);
/* On notera que l'on utilise 'EXPB(...)' et non pas 'EXPX(...)' a cause du bug */
/* 'BUG_SYSTEME_SG_C_exp'... */
RETU(fxy);
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O N D E L E T T E D E M O R L E T P A R T I E I M A G I N A I R E B I - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,Fpartie_imaginaire_de_l_ondelette_2D_de_Morlet(Xf,Yf)))
DEFV(Argument,DEFV(Float,Xf));
DEFV(Argument,DEFV(Float,Yf));
/* Coordonnees flottantes 'Xf' et 'Yf' dans [0,1[. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DONNEES_DE_CALCUL_DE_L_ONDELETTE_DE_MORLET_2D
/*..............................................................................................................................*/
ACCELERATION_ONDELETTE_DE_MORLET_2D;
EGAL(fxy
,MUL2(EXPB(NEGA(MOIT(ADD2(EXP2(Xf_dilate),EXP2(Yf_dilate))
)
)
)
,SINX(ADD2(MUL2(kcost_ondelette_2D_de_Morlet_courant,Xf_dilate)
,MUL2(ksint_ondelette_2D_de_Morlet_courant,Yf_dilate)
)
)
)
);
/* On notera que l'on utilise 'EXPB(...)' et non pas 'EXPX(...)' a cause du bug */
/* 'BUG_SYSTEME_SG_C_exp'... */
RETU(fxy);
Eblock
EFonctionF
#undef ACCELERATION_ONDELETTE_DE_MORLET_2D
#undef DONNEES_DE_CALCUL_DE_L_ONDELETTE_DE_MORLET_2D
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S B I - D I M E N S I O N N E L L E */
/* R E E L L E E T N O N A P P R O X I M E E ( O U " P A R F A I T E " ) : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,Fondelettes_2D_reelles_parfaites(fonction
,ARGUMENT_POINTERs(parametre_de_position_2D)
,ARGUMENT_POINTERs(parametre_d_echelle_2D)
,ARGUMENT_FONCTION(ondelette)
)
)
)
DEFV(Argument,DEFV(imageD,fonction));
/* Vecteur contenant la fonction discrete argument. */
DEFV(Argument,DEFV(pointF_2D,POINTERs(parametre_de_position_2D)));
/* Parametre de position ('b') qui est dans [0,1], et qui apres '_cDENORMALISE_OX()' */
/* sera un nombre entier... */
DEFV(Argument,DEFV(coeffF_2D,POINTERs(parametre_d_echelle_2D)));
/* Parametre d'echelle ('a'). */
DEFV(Argument,DEFV(Float,afPOINTEUR(ondelette)));
/* Definition de l'ondelette (par exemple, celle de Morlet -parties reelle et imaginaire-). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(pointD_2D,coordonnees_de_l_ondelette);
/* Coordonnees de l'ondelette obtenues a partir de {X,Y}. */
DEFV(Double,INIT(cumul_courant,FZERO));
/* Cumul courant donnant a la derniere etape ('INDEX_DE_DROITE_DE_L_ONDELETTE_2D' et */
/* 'INDEX_DU_HAUT_DE_L_ONDELETTE_2D') la valeur de la transformee de la fonction en (b,a). */
/*..............................................................................................................................*/
Test(IFOU(IZLE(ASI1(parametre_d_echelle_2D,cx))
,IZLE(ASI1(parametre_d_echelle_2D,cx))
)
)
Bblock
PRINT_ERREUR("le facteur d'echelle est negatif ou nul");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IFGE(INDEX_DE_GAUCHE_DE_L_ONDELETTE_2D,INDEX_DE_DROITE_DE_L_ONDELETTE_2D)
,IFGE(INDEX_DU_BAS_DE_L_ONDELETTE_2D,INDEX_DU_HAUT_DE_L_ONDELETTE_2D)
)
)
Bblock
PRINT_ERREUR("la definition des indices de l'ondelette est mauvaise");
Eblock
ATes
Bblock
Eblock
ETes
begin_image
Bblock
INITIALISATION_POINT_2D(coordonnees_de_l_ondelette
,DIVI(DPRE(SOUS(FLOT(X),F__cDENORMALISE_OX(ASI1(parametre_de_position_2D,x))))
,DPRE(ASI1(parametre_d_echelle_2D,cx))
)
,DIVI(DPRE(SOUS(FLOT(Y),F__cDENORMALISE_OY(ASI1(parametre_de_position_2D,y))))
,DPRE(ASI1(parametre_d_echelle_2D,cy))
)
);
/* Calcul de l'abscisse d'acces a l'ondelette : */
/* */
/* X-b */
/* x */
/* ------ */
/* a */
/* x */
/* */
/* et, */
/* */
/* calcul de l'ordonnee d'acces a l'ondelette : */
/* */
/* Y-b */
/* y */
/* ------ */
/* a */
/* y */
/* */
Test(IFET(INCLff(ASD1(coordonnees_de_l_ondelette,x)
,DPRE(INDEX_DE_GAUCHE_DE_L_ONDELETTE_2D)
,DPRE(INDEX_DE_DROITE_DE_L_ONDELETTE_2D)
)
,INCLff(ASD1(coordonnees_de_l_ondelette,y)
,DPRE(INDEX_DU_BAS_DE_L_ONDELETTE_2D)
,DPRE(INDEX_DU_HAUT_DE_L_ONDELETTE_2D)
)
)
)
Bblock
INCR(cumul_courant
,MUL2(fPOINTEUR(ondelette)(ASD1(coordonnees_de_l_ondelette,x),ASD1(coordonnees_de_l_ondelette,y))
,loadD_point(fonction,X,Y)
)
);
/* Iteration de calcul du produit de convolution entre la fonction et l'ondelette : */
/* */
/* Y=Ymax X=Xmax */
/* ___ ___ X-b Y-b */
/* \ \ 1 x y */
/* T(f,(b,a)) = / / -------.g(------,------).f(X,Y) */
/* --- --- a .a a a */
/* Y=Ymin X=Xmin x y x y */
/* */
/* ou encore : */
/* */
/* Y=Ymax X=Xmax */
/* ___ ___ X-b Y-b */
/* 1 \ \ x y */
/* T(f,(b,a)) = -------. / / g(------,------).f(X,Y) */
/* a .a --- --- a a */
/* x y Y=Ymin X=Xmin x y */
/* */
/* ou 'b' est le vecteur-parametre de position et 'a' le vecteur-parametre d'echelle. */
/* */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_image
RETU(DIVI(cumul_courant,MUL2(ASI1(parametre_d_echelle_2D,cx),ASI1(parametre_d_echelle_2D,cy))));
/* Renvoi de la valeur reelle de la transformee cherchee... */
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' O N D E L E T T E M O N O - D I M E N S I O N N E L L E */
/* A P P R O X I M E E P A R U N S P L I N E C U B I Q U E M O N O - D I M E N S I O N N E L : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Float,DTb1(Fondelettes_1D_____coefficient_X0_de_l_ondelette,LONGUEUR_DE_L_ONDELETTE_1D)));
/* Definition des coefficients C de l'ondelette. */
/* X,0 */
DEFV(Common,DEFV(Float,DTb1(Fondelettes_1D_____coefficient_X1_de_l_ondelette,LONGUEUR_DE_L_ONDELETTE_1D)));
/* Definition des coefficients C de l'ondelette. */
/* X,1 */
DEFV(Common,DEFV(Float,DTb1(Fondelettes_1D_____coefficient_X2_de_l_ondelette,LONGUEUR_DE_L_ONDELETTE_1D)));
/* Definition des coefficients C de l'ondelette. */
/* X,2 */
DEFV(Common,DEFV(Float,DTb1(Fondelettes_1D_____coefficient_X3_de_l_ondelette,LONGUEUR_DE_L_ONDELETTE_1D)));
/* Definition des coefficients C de l'ondelette. */
/* X,3 */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' A C C E L E R A T E U R M O N O - D I M E N S I O N N E L : */
/* */
/*************************************************************************************************************************************/
#define ACCES_AUX_CUMULS(cumul_S,x,y) \
COND(IFLT(x,Xmin) \
,FZERO \
,LIGNE(cumul_S,x,y) \
) \
/* Primitive d'acces a l'element 'x' de l'un des cumuls, avec les conventions "limites" */ \
/* suivantes : */ \
/* */ \
/* S (m) = 0 si m<Xmin (prise en compte ici), */ \
/* i */ \
/* = S (Xmax) si m>Xmax (prise en compte lors du calcul de 'x'). */ \
/* i */ \
/* */
DEFV(Local,DEFV(Logical,INIT(etat_des_cumuls_S,INVALIDE)));
/* Indicateur precisant si le calcul de S , S , S et S a ete fait. */
/* 0 1 2 3 */
#ifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
DEFV(Local,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X0)));
/* Pour contenir S , */
/* 0 */
DEFV(Local,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X1)));
/* Pour contenir S , */
/* 1 */
DEFV(Local,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X2)));
/* Pour contenir S , */
/* 2 */
DEFV(Local,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X3)));
/* Pour contenir S . */
/* 3 */
#Aifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
#Eifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
#ifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02 /* Common,DEFV(Fonction,) : objets statiques. */
/* voir le commentaire associe aux declarations 'static' lors de '$PASSE_7' de */
/* 'v $xcc/cpp$Z', ainsi que l'initialisation de la liste '$liste_utiles' qui y est faite... */
/* Le 20040521092725, le '#pragma' relatif a 'xcc__cpp_Z__liste_utiles' a ete introduit */
/* pour supprimer cette dependance... */
#pragma xcc__cpp_Z__liste_utiles $ximt/ondelettes$EXT Fondelettes_1D_____cumul_S_X0 $xbmt/ondelettes
DEFV(Common,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X0)));
/* Pour contenir S , */
/* 0 */
#pragma xcc__cpp_Z__liste_utiles $ximt/ondelettes$EXT Fondelettes_1D_____cumul_S_X1 $xbmt/ondelettes
DEFV(Common,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X1)));
/* Pour contenir S , */
/* 1 */
#pragma xcc__cpp_Z__liste_utiles $ximt/ondelettes$EXT Fondelettes_1D_____cumul_S_X2 $xbmt/ondelettes
DEFV(Common,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X2)));
/* Pour contenir S , */
/* 2 */
#pragma xcc__cpp_Z__liste_utiles $ximt/ondelettes$EXT Fondelettes_1D_____cumul_S_X3 $xbmt/ondelettes
DEFV(Common,DEFV(Statique,DEFV(ligneD,Fondelettes_1D_____cumul_S_X3)));
/* Pour contenir S . */
/* 3 */
#Aifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02 /* Common,DEFV(Fonction,) : objets statiques. */
#Eifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02 /* Common,DEFV(Fonction,) : objets statiques. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S M O N O - D I M E N S I O N N E L L E */
/* R E L L E E T A P P R O X I M E E : */
/* */
/*************************************************************************************************************************************/
BFonctionD
#define PARAMETRE_DE_POSITION_X \
AXPB(ASI1(parametre_d_echelle_1D,cx) \
,DPRE(X) \
,DPRE(F__cDENORMALISE_OX(ASI1(parametre_de_position_1D,x))) \
) \
/* Primitive permettant de calculer le parametre 'B' a partir de 'b'... */
DEFV(Common,DEFV(FonctionD,Fondelettes_1D_reelles_approximees(fonction
,ARGUMENT_POINTERs(parametre_de_position_1D)
,ARGUMENT_POINTERs(parametre_d_echelle_1D)
,il_faut_initialiser_les_cumuls_S
)
)
)
DEFV(Argument,DEFV(ligneD,fonction));
/* Vecteur contenant la fonction discrete argument. */
DEFV(Argument,DEFV(pointF_1D,POINTERs(parametre_de_position_1D)));
/* Parametre de position ('b') qui est dans [0,1], et qui apres '_cDENORMALISE_OX()' */
/* sera un nombre entier... */
DEFV(Argument,DEFV(coeffF_1D,POINTERs(parametre_d_echelle_1D)));
/* Parametre d'echelle ('a'). */
DEFV(Argument,DEFV(Logical,il_faut_initialiser_les_cumuls_S));
/* Cet indicateur indique s'il faut ('VRAI') ou pas ('FAUX') forcer la (re-)initialisation */
/* des differents cumuls 'cumul_S'... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(X_gauche,UNDEF));
DEFV(Int,INIT(X_droite,UNDEF));
/* Calcul pour 'X' courant des deux points (dits 'gauche' et 'droite' ou prendre les */
/* cumuls 'cumul_S' pour faire les differences)... */
DEFV(Double,INIT(cumul_courant,FZERO));
/* Cumul courant donnant a la derniere etape ('INDEX_DE_DROITE_DE_L_ONDELETTE_1D') */
/* la valeur de la transformee de la fonction en (b,a). */
DEFV(coeffD_1D,parametre_d_echelle_1D_P0);
/* Parametre d'echelle ('a') a la puissance 0, */
DEFV(coeffD_1D,parametre_d_echelle_1D_P1);
/* Parametre d'echelle ('a') a la puissance 1, */
DEFV(coeffD_1D,parametre_d_echelle_1D_P2);
/* Parametre d'echelle ('a') a la puissance 2, */
DEFV(coeffD_1D,parametre_d_echelle_1D_P3);
/* Parametre d'echelle ('a') a la puissance 3. */
DEFV(Double,INIT(ponderateur_du_premier_ordre,DPRE(UNDEF)));
/* Valeur de l'expression : */
/* */
/* 0 1 2 3 */
/* B B B B */
/* C .--- - C .--- + C .--- - C .--- */
/* X,0 0 X,1 1 X,2 2 X,3 3 */
/* a a a a */
/* */
DEFV(Double,INIT(ponderateur_du_deuxieme_ordre,DPRE(UNDEF)));
/* Valeur de l'expression : */
/* */
/* 0 1 2 */
/* B B B */
/* C .--- - 2.C .--- + 3.C .--- */
/* X,1 1 X,2 2 X,3 3 */
/* a a a */
/* */
DEFV(Double,INIT(ponderateur_du_troisieme_ordre,DPRE(UNDEF)));
/* Valeur de l'expression : */
/* */
/* 0 1 */
/* B B */
/* C .--- - 3.C .--- */
/* X,2 2 X,3 3 */
/* a a */
/* */
DEFV(Double,INIT(ponderateur_du_quatrieme_ordre,DPRE(UNDEF)));
/* Valeur de l'expression : */
/* */
/* 0 */
/* B */
/* C .--- */
/* X,3 3 */
/* a */
/* */
/*..............................................................................................................................*/
Test(IZLE(ASI1(parametre_d_echelle_1D,cx)))
Bblock
PRINT_ERREUR("le facteur d'echelle est negatif ou nul");
Eblock
ATes
Bblock
Eblock
ETes
Test(NINCff(CENTRE_DE_L_ONDELETTE_1D,INDEX_DE_GAUCHE_DE_L_ONDELETTE_1D,INDEX_DE_DROITE_DE_L_ONDELETTE_1D))
Bblock
PRINT_ERREUR("la definition des indices de l'ondelette est mauvaise");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(EST_VRAI(il_faut_initialiser_les_cumuls_S),EST_INVALIDE(etat_des_cumuls_S)))
Bblock
begin_ligne
Bblock
Test(IFLE(INTX(X),Xmin))
Bblock
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X0,X,Ymin)
,LIGNE(fonction,X,Ymin)
);
/* Initialisation du premier accelerateur : */
/* */
/* S (0) = f(0). */
/* 0 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X1,X,Ymin)
,FZERO
);
/* Initialisation du second accelerateur : */
/* */
/* S (0) = 0. */
/* 1 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X2,X,Ymin)
,FZERO
);
/* Initialisation du troisieme accelerateur : */
/* */
/* S (0) = 0. */
/* 2 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X3,X,Ymin)
,FZERO
);
/* Initialisation du quatrieme accelerateur : */
/* */
/* S (0) = 0. */
/* 3 */
/* */
Eblock
ATes
Bblock
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X0,X,Ymin)
,AXPB(EXP0(COXR(X))
,LIGNE(fonction,X,Ymin)
,LIGNE(Fondelettes_1D_____cumul_S_X0,PREX(X),Ymin)
)
);
/* Calcul du premier accelerateur : */
/* */
/* 0 */
/* S (X) = X .f(X) + S (X-1). */
/* 0 0 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X1,X,Ymin)
,AXPB(EXP1(COXR(X))
,LIGNE(fonction,X,Ymin)
,LIGNE(Fondelettes_1D_____cumul_S_X1,PREX(X),Ymin)
)
);
/* Calcul du second accelerateur : */
/* */
/* 1 */
/* S (X) = X .f(X) + S (X-1). */
/* 1 1 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X2,X,Ymin)
,AXPB(EXP2(COXR(X))
,LIGNE(fonction,X,Ymin)
,LIGNE(Fondelettes_1D_____cumul_S_X2,PREX(X),Ymin)
)
);
/* Calcul du troisieme accelerateur : */
/* */
/* 2 */
/* S (X) = X .f(X) + S (X-1). */
/* 2 2 */
/* */
EGAL(LIGNE(Fondelettes_1D_____cumul_S_X3,X,Ymin)
,AXPB(EXP3(COXR(X))
,LIGNE(fonction,X,Ymin)
,LIGNE(Fondelettes_1D_____cumul_S_X3,PREX(X),Ymin)
)
);
/* Calcul du quatrieme accelerateur : */
/* */
/* 3 */
/* S (X) = X .f(X) + S (X-1). */
/* 3 3 */
/* */
Eblock
ETes
Eblock
end_ligne
EGAL(etat_des_cumuls_S,VALIDE);
/* L'initialisation de l'accelerateur est achevee... */
Eblock
ATes
Bblock
Eblock
ETes
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D_P0,EXP0(ASI1(parametre_d_echelle_1D,cx)));
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D_P1,EXP1(ASI1(parametre_d_echelle_1D,cx)));
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D_P2,EXP2(ASI1(parametre_d_echelle_1D,cx)));
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D_P3,EXP3(ASI1(parametre_d_echelle_1D,cx)));
/* Preparation des differentes puissances du parametre d'echelle... */
begin_ligneQ(DoIn,INDEX_DE_GAUCHE_DE_L_ONDELETTE_1D,INDEX_DE_DROITE_DE_L_ONDELETTE_1D,PasX)
Bblock
/* Iteration de calcul du produit de convolution entre la fonction et l'ondelette. */
EGAL(X_gauche
,MIN2(INTX(COXA(AXPB(ASI1(parametre_d_echelle_1D,cx)
,FLOT(COXR(NEUT(X)))
,FLOT(PREX(F__cDENORMALISE_OX(ASI1(parametre_de_position_1D,x))))
)
)
)
,Xmax
)
);
EGAL(X_droite
,MIN2(INTX(COXA(AXPB(ASI1(parametre_d_echelle_1D,cx)
,FLOT(COXR(SUCX(X)))
,FLOT(PREX(F__cDENORMALISE_OX(ASI1(parametre_de_position_1D,x))))
)
)
)
,Xmax
)
);
/* Calcul pour 'X' courant des deux points (dits 'gauche' et 'droite' ou prendre les */
/* cumuls 'cumul_S' pour faire les differences). Les conditions "limites" suivantes sont */
/* utilisees : */
/* */
/* S (m) = 0 si m<0 (prise en compte a l'utilisation de 'X'), */
/* i */
/* = S (Xmax) si m>Xmax (prise en compte ici). */
/* i */
/* */
EGAL(ponderateur_du_premier_ordre
,HORNER_1_03(PARAMETRE_DE_POSITION_X
,NEUT(NEGA(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X3_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P3,cx)
)
)
)
,NEUT(NEUT(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X2_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P2,cx)
)
)
)
,NEUT(NEGA(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X1_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P1,cx)
)
)
)
,NEUT(NEUT(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X0_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P0,cx)
)
)
)
)
);
/* Calcul de la valeur de l'expression (suivant le schema de Horner) : */
/* */
/* 0 1 2 3 */
/* B B B B */
/* C .--- - C .--- + C .--- - C .--- */
/* X,0 0 X,1 1 X,2 2 X,3 3 */
/* a a a a */
/* */
EGAL(ponderateur_du_deuxieme_ordre
,HORNER_1_02(PARAMETRE_DE_POSITION_X
,NEUT(TRIP(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X3_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P3,cx)
)
)
)
,NEGA(DOUB(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X2_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P2,cx)
)
)
)
,NEUT(NEUT(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X1_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P1,cx)
)
)
)
)
);
/* Calcul de la valeur de l'expression (suivant le schema de Horner) : */
/* */
/* 0 1 2 */
/* B B B */
/* C .--- - 2.C .--- + 3.C .--- */
/* X,1 1 X,2 2 X,3 3 */
/* a a a */
/* */
EGAL(ponderateur_du_troisieme_ordre
,HORNER_1_01(PARAMETRE_DE_POSITION_X
,NEGA(TRIP(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X3_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P3,cx)
)
)
)
,NEUT(NEUT(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X2_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P2,cx)
)
)
)
)
);
/* Calcul de la valeur de l'expression (suivant le schema de Horner) : */
/* */
/* 0 1 */
/* B B */
/* C .--- - 3.C .--- */
/* X,2 2 X,3 3 */
/* a a */
/* */
EGAL(ponderateur_du_quatrieme_ordre
,HORNER_1_00(PARAMETRE_DE_POSITION_X
,NEUT(NEUT(VALEUR_DE_L_ONDELETTE_1D(Fondelettes_1D_____coefficient_X3_de_l_ondelette
,X,Ymin
,ASD1(parametre_d_echelle_1D_P3,cx)
)
)
)
)
);
/* Calcul de la valeur de l'expression (suivant le schema de Horner) : */
/* */
/* 0 */
/* B */
/* C .--- */
/* X,3 3 */
/* a */
/* */
INCR(cumul_courant
,ADD4(MUL2(ponderateur_du_premier_ordre
,SOUS(ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X0,X_droite,Ymin)
,ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X0,X_gauche,Ymin)
)
)
,MUL2(ponderateur_du_deuxieme_ordre
,SOUS(ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X1,X_droite,Ymin)
,ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X1,X_gauche,Ymin)
)
)
,MUL2(ponderateur_du_troisieme_ordre
,SOUS(ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X2,X_droite,Ymin)
,ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X2,X_gauche,Ymin)
)
)
,MUL2(ponderateur_du_quatrieme_ordre
,SOUS(ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X3,X_droite,Ymin)
,ACCES_AUX_CUMULS(Fondelettes_1D_____cumul_S_X3,X_gauche,Ymin)
)
)
)
);
Eblock
end_ligneQ(EDoI)
RETU(DIVI(cumul_courant,ASI1(parametre_d_echelle_1D,cx)));
/* Renvoi de la valeur reelle de la transformee cherchee... */
Eblock
#undef PARAMETRE_DE_POSITION_X
EFonctionD
#undef ACCES_AUX_CUMULS
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S B I - D I M E N S I O N N E L L E R E E L L E */
/* */
/*************************************************************************************************************************************/
BFonctionP
DEFV(Common,DEFV(FonctionP,POINTERp(Iondelettes_2D_reelles(imageR
,imageA
,ARGUMENT_POINTERs(parametre_d_echelleA_2D)
,renormaliser_l_image
,ARGUMENT_FONCTION(ondelette)
)
)
)
)
DEFV(Argument,DEFV(image,imageR));
/* Image transformee de l'image argument. */
DEFV(Argument,DEFV(image,imageA));
/* Image Argument. */
DEFV(Argument,DEFV(coeffF_2D,POINTERs(parametre_d_echelleA_2D)));
/* Parametre d'echelle ('a'). */
DEFV(Argument,DEFV(Logical,renormaliser_l_image));
/* Indicateur precisant s'il faut a priori renormaliser 'imageR' ('VRAI') */
/* ou laisser choisir le programme en fonction du couple (minimum,maximum) */
/* calcule ('FAUX'). */
DEFV(Argument,DEFV(Float,afPOINTEUR(ondelette)));
/* Definition de l'ondelette (par exemple, celle de Morlet -parties reelle et imaginaire-). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(pointF_2D,parametre_de_position_2D);
/* Parametre de position pour la transformee mono-dimensionnelle ('b'). */
DEFV(coeffF_2D,parametre_d_echelle_2D);
/* Parametre d'echelle pour la transformee mono-dimensionnelle ('a'). */
BDEFV(imageD,image_courante);
/* Image courante, */
DEFV(Double,INIT(minimum_de_la_transformee,DPRE(UNDEF)));
DEFV(Double,INIT(maximum_de_la_transformee,DPRE(UNDEF)));
/* Donnent le minimum et le maximum de la transformee finale flottante. */
/*..............................................................................................................................*/
INITIALISATION_COEFFICIENT_2D(parametre_d_echelle_2D
,ASI1(parametre_d_echelleA_2D,cx)
,ASI1(parametre_d_echelleA_2D,cy)
);
/* Initialisation du parametre d'echelle bi-dimensionnel. */
begin_image
Bblock
storeD_point(load_point(imageA,X,Y),image_courante,X,Y);
/* Conversion de l'image Argument en la fonction a transformer. */
Eblock
end_image
begin_image
Bblock
INITIALISATION_POINT_2D(parametre_de_position_2D
,_____cNORMALISE_OX(X)
,_____cNORMALISE_OY(Y)
);
/* Initialisation du parametre de position a l'aide des coordonnees courantes {X,Y}. */
storeD_point(Fondelettes_2D_reelles_parfaites(image_courante
,ADRESSE(parametre_de_position_2D)
,ADRESSE(parametre_d_echelle_2D)
,aFONCTION(ondelette)
)
,image_courante
,X,Y
);
/* Generation de la transformee en ondelettes bi-dimensionelle, point apres point... */
Eblock
end_image
CALS(IDnivo_extrema(image_courante
,ADRESSE(minimum_de_la_transformee)
,ADRESSE(maximum_de_la_transformee)
)
);
/* Recherche du minimum et du maximum de la transformee finale flottante. */
Test(IFOU(IL_FAUT(renormaliser_l_image)
,IFOU(IFLT(minimum_de_la_transformee,FLOT__NOIR)
,IFGT(maximum_de_la_transformee,FLOT__BLANC)
)
)
)
/* Nota : on n'oubliera pas que par definition 'minimum <= maximum'... */
Bblock
CALS(Idouble_std(imageR
,image_courante
,minimum_de_la_transformee
,maximum_de_la_transformee
)
);
/* Lorsque les niveaux minimal et maximal sont hors de [NOIR,BLANC], */
/* ou bien si la renormalisation explicite est demandee, on renormalise... */
Eblock
ATes
Bblock
CALS(Idouble_std(imageR
,image_courante
,FLOT__NOIR
,FLOT__BLANC
)
);
/* Les niveaux minimal et maximal sont dans [NOIR,BLANC] et on */
/* ne renormalise pas... */
Eblock
ETes
EDEFV(imageD,image_courante);
/* Image courante. */
RETI(imageR);
Eblock
EFonctionP
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S B I - D I M E N S I O N N E L L E R E E L L E */
/* O B T E N U E P A R P R O D U I T D E D E U X T R A N S F O R M E E S E N O N D E L E T T E S */
/* M O N O - D I M E N S I O N N E L L E S O R T H O G O N A L E S E T R E E L L E S : */
/* */
/*************************************************************************************************************************************/
BFonctionP
DEFV(Common,DEFV(FonctionP,POINTERp(Iondelettes_2D_HV_reelles(imageR
,imageA
,ARGUMENT_POINTERs(parametre_d_echelleA_2D)
,renormaliser_l_image
)
)
)
)
DEFV(Argument,DEFV(image,imageR));
/* Image transformee de l'image argument. */
DEFV(Argument,DEFV(image,imageA));
/* Image Argument. */
DEFV(Argument,DEFV(coeffF_2D,POINTERs(parametre_d_echelleA_2D)));
/* Parametre d'echelle ('a'). */
DEFV(Argument,DEFV(Logical,renormaliser_l_image));
/* Indicateur precisant s'il faut a priori renormaliser 'imageR' ('VRAI') */
/* ou laisser choisir le programme en fonction du couple (minimum,maximum) */
/* calcule ('FAUX'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(pointF_1D,parametre_de_position_1D);
/* Parametre de position pour la transformee mono-dimensionnelle ('b'). */
DEFV(coeffF_1D,parametre_d_echelle_1D);
/* Parametre d'echelle pour la transformee mono-dimensionnelle ('a'). */
BDEFV(ligneD,ligne_courante);
/* Ligne courante, */
BDEFV(colonneD,colonne_courante);
/* Colonne courante, */
BDEFV(imageF,transformeeH_de_l_imageA);
/* Image transformee de l'image argument (elle est dite Horizontale, car elle correspond */
/* a la premiere etape qui s'interesee aux lignes). */
BDEFV(imageF,transformeeV_de_l_imageA);
/* Image transformee de l'image argument (elle est dite Verticale, car elle correspond */
/* a la deuxieme etape qui s'interesee aux colonnes). */
DEFV(Logical,INIT(il_faut_initialiser_les_cumuls_S,LUNDEF));
/* Cet indicateur indique s'il faut ('VRAI') ou pas ('FAUX') forcer la (re-)initialisation */
/* des differents cumuls 'cumul_S'... */
DEFV(genere_Float,INIT(minimum_de_la_transformee,FLOT__UNDEF));
DEFV(genere_Float,INIT(maximum_de_la_transformee,FLOT__UNDEF));
/* Donnent le minimum et le maximum de la transformee finale flottante. */
/*..............................................................................................................................*/
Test(IFOU(IFNE(dimX,dimY)
,IFNE(pasX,pasY)
)
)
Bblock
PRINT_ERREUR("la definition des images est incompatible avec l'algorithme");
Eblock
ATes
Bblock
Eblock
ETes
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D,ASI1(parametre_d_echelleA_2D,cx));
/* Initialisation du parametre d'echelle mono-dimensionnel sur la dimension horizontale. */
begin_colonne
Bblock
/* On transforme d'abord horizontalement : */
/* */
/* Y ^ */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* -O--------------------> */
/* | X */
/* */
/* (ligne apres ligne). */
begin_ligne
Bblock
EGAL(LIGNE(ligne_courante,X,Y)
,DPRE(load_point(imageA,X,Y))
);
/* Recuperation de la ligne courante dans 'imageA' (c'est-a-dire */
/* l'image Argument), */
Eblock
end_ligne
EGAL(il_faut_initialiser_les_cumuls_S,VRAI);
/* Ainsi, on ree-initialise les 'cumul_S' au debut de chaque ligne... */
begin_ligne
Bblock
INITIALISATION_POINT_1D(parametre_de_position_1D,_____cNORMALISE_OX(X));
/* Initialisation du parametre de position a l'aide de l'abscisse courante 'X'. */
storeF_point(Fondelettes_1D_reelles(ligne_courante
,ADRESSE(parametre_de_position_1D)
,ADRESSE(parametre_d_echelle_1D)
,il_faut_initialiser_les_cumuls_S
,ONDELETTE_1D_REELLE
)
,transformeeH_de_l_imageA
,X,Y
);
/* Generation de la transformee en ondelettes bi-dimensionelle, ligne */
/* apres ligne... */
EGAL(il_faut_initialiser_les_cumuls_S,FAUX);
/* Ainsi, on ree-initialise les 'cumul_S' au debut de chaque ligne... */
Eblock
end_ligne
Eblock
end_colonne
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D,ASI1(parametre_d_echelleA_2D,cy));
/* Initialisation du parametre d'echelle mono-dimensionnel sur la dimension verticale. */
begin_ligne
Bblock
/* Puis, on transforme verticalement : */
/* */
/* Y ^ */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* -O--------------------> */
/* | X */
/* */
/* (colonne apres colonne). */
begin_colonne
Bblock
EGAL(COLONNE(colonne_courante,X,Y)
,DPRE(loadF_point(transformeeH_de_l_imageA,X,Y))
);
/* Recuperation de la colonne courante dans 'transformeeH_de_l_imageA' */
/* (c'est-a-dire la transformee en ondelettes "horizontale" de 'imageA'), */
Eblock
end_colonne
EGAL(il_faut_initialiser_les_cumuls_S,VRAI);
/* Ainsi, on ree-initialise les 'cumul_S' au debut de chaque colonne... */
begin_colonne
Bblock
INITIALISATION_POINT_1D(parametre_de_position_1D,_____cNORMALISE_OY(Y));
/* Initialisation du parametre de position a l'aide de l'ordonnee courante 'Y'. */
storeF_point(Fondelettes_1D_reelles(colonne_courante
,ADRESSE(parametre_de_position_1D)
,ADRESSE(parametre_d_echelle_1D)
,il_faut_initialiser_les_cumuls_S
,ONDELETTE_1D_REELLE
)
,transformeeV_de_l_imageA
,X,Y
);
/* Generation de la transformee en ondelettes bi-dimensionelle, colonne */
/* apres colonne... */
EGAL(il_faut_initialiser_les_cumuls_S,FAUX);
/* Ainsi, on re-initialise les 'cumul_S' au debut de chaque colonne... */
Eblock
end_colonne
Eblock
end_ligne
CALS(IFnivo_extrema(transformeeV_de_l_imageA
,ADRESSE(minimum_de_la_transformee)
,ADRESSE(maximum_de_la_transformee)
)
);
/* Recherche du minimum et du maximum de la transformee finale flottante. */
Test(IFOU(IL_FAUT(renormaliser_l_image)
,IFOU(IFLT(minimum_de_la_transformee,FLOT__NOIR)
,IFGT(maximum_de_la_transformee,FLOT__BLANC)
)
)
)
/* Nota : on n'oubliera pas que par definition 'minimum <= maximum'... */
Bblock
CALS(Ifloat_std(imageR
,transformeeV_de_l_imageA
,minimum_de_la_transformee
,maximum_de_la_transformee
)
);
/* Lorsque les niveaux minimal et maximal sont hors de [NOIR,BLANC], */
/* ou bien si la renormalisation explicite est demandee, on renormalise... */
Eblock
ATes
Bblock
CALS(Ifloat_std(imageR
,transformeeV_de_l_imageA
,FLOT__NOIR
,FLOT__BLANC
)
);
/* Les niveaux minimal et maximal sont dans [NOIR,BLANC] et on */
/* ne renormalise pas... */
Eblock
ETes
EDEFV(imageF,transformeeV_de_l_imageA);
/* Image transformee de l'image argument (elle est dite Verticale, car elle correspond */
/* a la deuxieme etape qui s'interesee aux colonnes). */
EDEFV(imageF,transformeeH_de_l_imageA);
/* Image transformee de l'image argument (elle est dite Horizontale, car elle correspond */
/* a la premiere etape qui s'interesee aux lignes). */
EDEFV(colonneD,colonne_courante);
/* Colonne courante, */
EDEFV(ligneD,ligne_courante);
/* Ligne courante. */
RETI(imageR);
Eblock
EFonctionP
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E E N O N D E L E T T E S M O N O - D I M E N S I O N N E L L E C O M P L E X E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define INTERPOLATION_DES_ECHELLES(y) \
BARY(parametre_d_echelle_minimal \
,parametre_d_echelle_maximal \
,DIVI(FLOT(COYR(y)),FLOT(COYR(Ymax))) \
) \
/* Definition du passage de la coordonnee 'Y' au parametre d'echelle. */
#define PARAMETRE_D_ECHELLE(y) \
COND(IL_FAUT(echelles_lineaires) \
,INTERPOLATION_DES_ECHELLES(y) \
,EXPB(INTERPOLATION_DES_ECHELLES(y)) \
) \
/* Definition du passage de la coordonnee 'Y' au parametre d'echelle. */ \
/* */ \
/* On notera que l'on utilise 'EXPB(...)' et non pas 'EXPX(...)' a cause du bug */ \
/* 'BUG_SYSTEME_SG_C_exp'... */
DEFV(Common,DEFV(FonctionI,Iondelettes_1D_complexes(partie_reelleR
,partie_imaginaireR
,moduleR
,phaseR
,fonction
,ARGUMENT_POINTERs(frequences)
,echelles_lineaires
,parametre_d_echelle_minimal
,parametre_d_echelle_maximal
)
)
)
DEFV(Argument,DEFV(image,partie_reelleR));
/* Image dans laquelle se trouvera au retour la partie reelle des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a', */
DEFV(Argument,DEFV(image,partie_imaginaireR));
/* Image dans laquelle se trouvera au retour la partie imaginaire des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
DEFV(Argument,DEFV(image,moduleR));
/* Image contenant le module au retour, */
DEFV(Argument,DEFV(image,phaseR));
/* Image contenant la phase au retour. */
DEFV(Argument,DEFV(ligneD,fonction));
/* Vecteur contenant la fonction discrete argument. */
DEFV(Argument,DEFV(coeffF_2D,POINTERs(frequences)));
/* Frequences 'reelle' et 'imaginaire' argument pour initialiser l'ondelette de Morlet ; en */
/* general le couple (PI,PI) sera utilise. */
DEFV(Argument,DEFV(Logical,echelles_lineaires));
/* Cet indicateur precise si les echelles a utiliser sont lineaires ('VRAI') ou */
/* logarithmiques ('FAUX'). */
DEFV(Argument,DEFV(Float,parametre_d_echelle_minimal));
/* Valeur minimale du parametre d'echelle, */
DEFV(Argument,DEFV(Float,parametre_d_echelle_maximal));
/* Valeur maximale du parametre d'echelle. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Logical,INIT(reinitialisation_des_cumuls_S,VRAI));
/* Indicateur destine a forcer l'initialisation des 'cumul_S' la toute premiere fois ; par */
/* la suite, ces valeurs seront valables aussi bien pour la partie reelle que pour la */
/* partie imaginaire. */
DEFV(pointF_1D,parametre_de_position_1D);
/* Parametre de position ('b'). */
DEFV(coeffF_1D,parametre_d_echelle_1D);
/* Parametre d'echelle ('a'). */
BDEFV(imageF,partie_reelle);
/* Matrice flottante dans laquelle se trouvera la partie reelle des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a', */
BDEFV(imageF,partie_imaginaire);
/* Matrice flottante dans laquelle se trouvera la partie imaginaire des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
BDEFV(imageF,module);
/* Matrice flottante dans laquelle se trouvera le module des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
BDEFV(imageF,phase);
/* Matrice flottante dans laquelle se trouvera la phase des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
/*..............................................................................................................................*/
EGAL(Fondelettes_1D_____frequence_reelle,ASI1(frequences,cx));
GENERATION_DE_LA_PARTIE_REELLE_DE_L_ONDELETTE_1D;
/* Initialisation de l'ondelette avec la partie reelle. */
begin_image
Bblock
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D,PARAMETRE_D_ECHELLE(Y));
INITIALISATION_POINT_1D(parametre_de_position_1D,_____cNORMALISE_OX(X));
/* Initialisation des parametres d'echelle et de position avec 'Y' et 'X' respectivement. */
storeF_point(Fondelettes_1D_reelles(fonction
,ADRESSE(parametre_de_position_1D)
,ADRESSE(parametre_d_echelle_1D)
,reinitialisation_des_cumuls_S
,ONDELETTE_1D_PARTIE_REELLE
)
,partie_reelle
,X,Y
);
/* Calcul de la partie reelle de la transformee. */
EGAL(reinitialisation_des_cumuls_S,FAUX);
/* Afin de ne plus faire aucune reinitialisation des 'cumul_S'. */
Eblock
end_image
CALS(Ifloat_std_avec_renormalisation(partie_reelleR
,partie_reelle
)
);
/* Generation de l'image "partie reelle" (avec renormalisation). */
EGAL(Fondelettes_1D_____frequence_imaginaire,ASI1(frequences,cy));
GENERATION_DE_LA_PARTIE_IMAGINAIRE_DE_L_ONDELETTE_1D;
begin_image
Bblock
INITIALISATION_COEFFICIENT_1D(parametre_d_echelle_1D,PARAMETRE_D_ECHELLE(Y));
INITIALISATION_POINT_1D(parametre_de_position_1D,_____cNORMALISE_OX(X));
/* Initialisation des parametres d'echelle et de position avec 'Y' et 'X' respectivement. */
storeF_point(Fondelettes_1D_reelles(fonction
,ADRESSE(parametre_de_position_1D)
,ADRESSE(parametre_d_echelle_1D)
,reinitialisation_des_cumuls_S
,ONDELETTE_1D_PARTIE_IMAGINAIRE
)
,partie_imaginaire
,X,Y
);
/* Calcul de la partie imaginaire de la transformee. */
EGAL(reinitialisation_des_cumuls_S,FAUX);
/* Afin de ne plus faire aucune reinitialisation des 'cumul_S' (inutile ici puisqu'il */
/* a ete fait lors de l'iteration sur la partie reelle). */
Eblock
end_image
CALS(Ifloat_std_avec_renormalisation(partie_imaginaireR
,partie_imaginaire
)
);
/* Generation de l'image "partie imaginaire" (avec renormalisation). */
CALS(Iconversion_XY_RT(module,phase
,partie_reelle,partie_imaginaire
)
);
/* Calcul des modules et des phases dans [0,2.PI], puis dans [NOIR,BLANC]... */
CALS(Ifloat_std_avec_renormalisation(moduleR
,module
)
);
/* Generation de l'image "module" (avec renormalisation). */
CALS(Ifloat_std(phaseR
,phase
,FZERO
,CERCLE_TRIGONOMETRIQUE
)
);
/* Generation de l'image "phase" (sans renormalisation, afin de conserver toute */
/* l'information, et en particulier voir des "trous" dans [0,2.PI]). */
EDEFV(imageF,phase);
/* Matrice flottante dans laquelle se trouvera la phase des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
EDEFV(imageF,module);
/* Matrice flottante dans laquelle se trouvera le module des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
EDEFV(imageF,partie_imaginaire);
/* Matrice flottante dans laquelle se trouvera la partie imaginaire des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
EDEFV(imageF,partie_reelle);
/* Matrice flottante dans laquelle se trouvera la partie reelle des transformees */
/* complexes mono_dimensionnelles de la fonction pour des valeurs differentes du */
/* parametre 'a'. */
RETU_ERROR;
Eblock
#undef PARAMETRE_D_ECHELLE
#undef INTERPOLATION_DES_ECHELLES
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A P P R O X I M A T I O N D ' U N E F O N C T I O N E C H A N T I L L O N E E */
/* P A R U N S P L I N E C U B I Q U E M O N O - D I M E N S I O N N E L : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define PREMIER_ELEMENT_DE_LA_FONCTION \
INDEX0 \
/* Premier element des vecteurs de definition de la fonction et des vecteurs */ \
/* des coefficients d'approximation. */
#define DELTA_VECTEUR(ITbX,vecteur,indice2,indice1) \
SOUS(ITbX(vecteur,INDX(indice2,PREMIER_ELEMENT_DE_LA_FONCTION)) \
,ITbX(vecteur,INDX(indice1,PREMIER_ELEMENT_DE_LA_FONCTION)) \
) \
/* Calcul d'un accroissement sur un 'vecteur' d'un indice (1) a un autre (2). */
DEFV(Common,DEFV(FonctionI,Fapproximation_par_un_spline_cubique(coefficients_de_degre_0
,coefficients_de_degre_1
,coefficients_de_degre_2
,coefficients_de_degre_3
,liste_des_abscisses
,liste_des_ordonnees
,premiere_derivee_premiere
,derniere_derivee_premiere
,nombre_d_echantillons
)
)
)
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_0)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_1)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_2)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_3)));
/* Vecteurs donnant au retour les coeficients respectifs des quatre puissances */
/* de la variable 'X' (a savoir 0, 1, 2 et 3). Mais ATTENTION, il est renvoye ainsi */
/* un point de moins que la fonction n'en contient... */
DEFV(Argument,DEFV(Float,DTb0(liste_des_abscisses)));
DEFV(Argument,DEFV(Float,DTb0(liste_des_ordonnees)));
/* Vecteurs contenant a l'entree la definition en {X,Y} de la fonction echantillonnee. Mais */
/* ils contiennent un point de plus que n'en contiennent au retour les coefficients */
/* ci-dessus... */
DEFV(Argument,DEFV(Float,premiere_derivee_premiere));
DEFV(Argument,DEFV(Float,derniere_derivee_premiere));
/* Definition de la derivee premiere de la fonction argument au premier et au */
/* dernier points respectivement. */
DEFV(Argument,DEFV(Positive,nombre_d_echantillons));
/* Nombre d'echantillons definissant la fonction argument en {X,Y}, c'est donc la dimension */
/* des vecteurs 'liste_des_abscisses' et 'liste_des_ordonnees', mais c'est la dimension */
/* plus 1 des quatre vecteurs de coefficients renvoyes au 'RETU'... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Float,DdTb1(POINTERf
,derivee_seconde
,nombre_d_echantillons
,fMalo(MUL2(nombre_d_echantillons,size_Float))
)
);
/* Allocation d'un vecteur destine a stocker la derivee seconde en chaque point. */
DEFV(Float,DdTb1(POINTERf
,vecteur_de_manoeuvre
,nombre_d_echantillons
,fMalo(MUL2(nombre_d_echantillons,size_Float))
)
);
/* Allocation d'un vecteur de manoeuvre. */
DEFV(Int,INIT(index,UNDEF));
/* Definition de l'index d'iteration. */
DEFV(Float,INIT(taux_de_variation_de_l_abscisse,FLOT__UNDEF));
/* Pour calculer le taux de variation des abscisses. */
DEFV(Float,INIT(produit_du_taux_par_la_derivee_seconde,FLOT__UNDEF));
/* Pour calculer le produit du taux de variation de l'abscisse par la derivee seconde. */
/*..............................................................................................................................*/
EGAL(IdTb1(derivee_seconde,INDX(PREMIER_ELEMENT_DE_LA_FONCTION,PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons),NEGA(FDU));
EGAL(IdTb1(vecteur_de_manoeuvre,INDX(PREMIER_ELEMENT_DE_LA_FONCTION,PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
,MUL2(TRIP(fINVZ(DELTA_VECTEUR(ITb0
,liste_des_abscisses
,SUCC(PREMIER_ELEMENT_DE_LA_FONCTION)
,NEUT(PREMIER_ELEMENT_DE_LA_FONCTION)
)
)
)
,SOUS(fDIVZ(DELTA_VECTEUR(ITb0
,liste_des_ordonnees
,SUCC(PREMIER_ELEMENT_DE_LA_FONCTION)
,NEUT(PREMIER_ELEMENT_DE_LA_FONCTION)
)
,DELTA_VECTEUR(ITb0
,liste_des_abscisses
,SUCC(PREMIER_ELEMENT_DE_LA_FONCTION)
,NEUT(PREMIER_ELEMENT_DE_LA_FONCTION)
)
)
,premiere_derivee_premiere
)
)
);
/* Initialisation de l'iteration suivante... */
/* */
/* Le 20071201105658 'DIVZ(...)' et 'INVZ(...)' furent remplaces tardivement par */
/* 'fDIVZ(...)' et 'fINVZ(...)'... */
DoIn(index
,SUCC(PREMIER_ELEMENT_DE_LA_FONCTION)
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PasX
)
Bblock
EGAL(taux_de_variation_de_l_abscisse
,fDIVZ(DELTA_VECTEUR(ITb0,liste_des_abscisses,NEUT(index),PRED(index))
,DELTA_VECTEUR(ITb0,liste_des_abscisses,SUCC(index),PRED(index))
)
);
/* Pour calculer le taux de variation des abscisses. */
/* */
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
EGAL(produit_du_taux_par_la_derivee_seconde
,ADD2(MUL2(taux_de_variation_de_l_abscisse
,IdTb1(derivee_seconde,INDX(PRED(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
)
,FDEUX
)
);
/* Pour calculer le produit du taux de variation de l'abscisse par la derviee seconde. */
EGAL(IdTb1(derivee_seconde,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
,fDIVZ(SOUS(taux_de_variation_de_l_abscisse
,FU
)
,produit_du_taux_par_la_derivee_seconde
)
);
/* Calcul "provisoire" de la derivee seconde. */
/* */
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
EGAL(IdTb1(vecteur_de_manoeuvre,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
,fDIVZ(SOUS(GRO6(fDIVZ(SOUS(fDIVZ(DELTA_VECTEUR(ITb0,liste_des_ordonnees,SUCC(index),NEUT(index))
,DELTA_VECTEUR(ITb0,liste_des_abscisses,SUCC(index),NEUT(index))
)
,fDIVZ(DELTA_VECTEUR(ITb0,liste_des_ordonnees,NEUT(index),PRED(index))
,DELTA_VECTEUR(ITb0,liste_des_abscisses,NEUT(index),PRED(index))
)
)
,DELTA_VECTEUR(ITb0,liste_des_abscisses,SUCC(index),PRED(index))
)
)
,MUL2(taux_de_variation_de_l_abscisse
,IdTb1(vecteur_de_manoeuvre,INDX(PRED(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
)
)
,produit_du_taux_par_la_derivee_seconde
)
);
/* Calcul du mysterieux vecteur de manoeuvre... */
/* */
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
Eblock
EDoI
EGAL(IdTb1(vecteur_de_manoeuvre
,INDX(NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PREMIER_ELEMENT_DE_LA_FONCTION
)
,nombre_d_echantillons
)
,MUL2(FLOT(TROIS)
,fDIVZ(SOUS(derniere_derivee_premiere
,fDIVZ(DELTA_VECTEUR(ITb0
,liste_des_ordonnees
,NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
)
,DELTA_VECTEUR(ITb0
,liste_des_abscisses
,NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
)
)
)
,DELTA_VECTEUR(ITb0
,liste_des_abscisses
,NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
)
)
)
);
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
EGAL(IdTb1(derivee_seconde
,INDX(NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PREMIER_ELEMENT_DE_LA_FONCTION
)
,nombre_d_echantillons
)
,fDIVZ(SOUS(NEUT(IdTb1(vecteur_de_manoeuvre
,INDX(NEUT(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PREMIER_ELEMENT_DE_LA_FONCTION
)
,nombre_d_echantillons
)
)
,MOIT(IdTb1(vecteur_de_manoeuvre
,INDX(PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PREMIER_ELEMENT_DE_LA_FONCTION
)
,nombre_d_echantillons
)
)
)
,ADD2(FU
,MOIT(IdTb1(derivee_seconde
,INDX(PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons)),PREMIER_ELEMENT_DE_LA_FONCTION)
,nombre_d_echantillons
)
)
)
)
);
/* Calcul "provisoire" de la derivee seconde. */
/* */
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
DoDe(index
,PREMIER_ELEMENT_DE_LA_FONCTION
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PasX
)
Bblock
EGAL(IdTb1(derivee_seconde,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
,ADD2(MUL2(IdTb1(derivee_seconde,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
,IdTb1(derivee_seconde,INDX(SUCC(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
)
,IdTb1(vecteur_de_manoeuvre,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons)
)
);
/* Calcul final de la derivee seconde... */
Eblock
EDoD
DoIn(index
,PREMIER_ELEMENT_DE_LA_FONCTION
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PasX
)
Bblock
EGAL(ITb1(coefficients_de_degre_0,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,ITb1(liste_des_ordonnees,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION))
);
/* */
/* C = Y(i) */
/* 0,i */
/* */
EGAL(ITb1(coefficients_de_degre_1,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,SOUS(fDIVZ(DELTA_VECTEUR(ITb0,liste_des_ordonnees,SUCC(index),NEUT(index))
,DELTA_VECTEUR(ITb0,liste_des_abscisses,SUCC(index),NEUT(index))
)
,TIER(ADD2(NEUT(IdTb1(derivee_seconde,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons))
,MOIT(IdTb1(derivee_seconde,INDX(SUCC(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons))
)
)
)
);
/* */
/* 2 2 */
/* Y(i+1) - Y(i) 1 d Y 1 d Y */
/* C = --------------- - ---.[-----(i) + ---.-----(i+1)] */
/* 1,i X(i+1) - X(i) 3 2 2 2 */
/* d X d X */
/* */
/* Le 20071201110339 'DIVZ(...)' fut remplace tardivement par 'fDIVZ(...)'... */
EGAL(ITb1(coefficients_de_degre_2,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,MOIT(IdTb1(derivee_seconde,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION),nombre_d_echantillons))
);
/* */
/* 2 */
/* 1 d Y */
/* C = ---.-----(i) */
/* 2,i 2 2 */
/* d X */
/* */
EGAL(ITb1(coefficients_de_degre_3,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,FRA6(fDIVZ(DELTA_VECTEUR(ITb1,derivee_seconde,SUCC(index),NEUT(index))
,DELTA_VECTEUR(ITb0,liste_des_abscisses,SUCC(index),NEUT(index))
)
)
);
/* */
/* 2 2 */
/* d Y d Y */
/* -----(i+1) - -----(i) */
/* 2 2 */
/* 1 d X d X */
/* C = ---.----------------------- */
/* 3,i 6 X(i+1) - X(i) */
/* */
/* */
Eblock
EDoI
/* Nota : l'element 'nombre_d_echantillons' des quatre vecteurs de coefficients n'existe */
/* pas, et n'est donc pas calcule... */
FdTb1(vecteur_de_manoeuvre,nombre_d_echantillons,Float,ADRESSE_PLUS_DEFINIE);
/* Liberation du vecteur mysterieux... */
/* */
/* Le 'ADRESSE_PLUS_DEFINIE' a ete introduit le 20050221170441... */
FdTb1(derivee_seconde,nombre_d_echantillons,Float,ADRESSE_PLUS_DEFINIE);
/* Liberation du vecteur contenant la derivee seconde. */
/* */
/* Le 'ADRESSE_PLUS_DEFINIE' a ete introduit le 20050221170441... */
RETU_ERROR;
Eblock
#undef DELTA_VECTEUR
#undef PREMIER_ELEMENT_DE_LA_FONCTION
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A P P R O X I M A T I O N D ' U N E F O N C T I O N E C H A N T I L L O N E E */
/* P A R U N E S E R I E D E P O L Y N O M E S D E D E G R E 3 S E R A C C O R D A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define PREMIER_ELEMENT_DE_LA_FONCTION \
INDEX0 \
/* Premier element des vecteurs de definition de la fonction et des vecteurs */ \
/* des coefficients d'approximation. */
#define DELTA_VECTEUR(vecteur,indice2,indice1) \
SOUS(ITb0(vecteur,INDX(indice2,PREMIER_ELEMENT_DE_LA_FONCTION)) \
,ITb0(vecteur,INDX(indice1,PREMIER_ELEMENT_DE_LA_FONCTION)) \
) \
/* Calcul d'un accroissement sur un 'vecteur' d'un indice (1) a un autre (2). */
DEFV(Common,DEFV(FonctionI,Fapproximation_par_des_polynomes_cubiques(coefficients_de_degre_0
,coefficients_de_degre_1
,coefficients_de_degre_2
,coefficients_de_degre_3
,liste_des_abscisses
,liste_des_ordonnees
,liste_des_derivees_premieres
,nombre_d_echantillons
)
)
)
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_0)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_1)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_2)));
DEFV(Argument,DEFV(Float,DTb0(coefficients_de_degre_3)));
/* Vecteurs donnant au retour les coeficients respectifs des quatre puissances */
/* de la variable 'X' (a savoir 0, 1, 2 et 3). Mais ATTENTION, il est renvoye ainsi */
/* un point de moins que la fonction n'en contient... */
DEFV(Argument,DEFV(Float,DTb0(liste_des_abscisses)));
DEFV(Argument,DEFV(Float,DTb0(liste_des_ordonnees)));
/* Vecteurs contenant a l'entree la definition en {X,Y} de la fonction echantillonnee. Mais */
/* ils contiennent un point de plus que n'en contiennent au retour les coefficients */
/* ci-dessus... */
DEFV(Argument,DEFV(Float,DTb0(liste_des_derivees_premieres)));
/* Definition des derivees premieres en chacun des points echantillonnes. */
DEFV(Argument,DEFV(Positive,nombre_d_echantillons));
/* Nombre d'echantillons definissant la fonction argument en {X,Y}, c'est donc la dimension */
/* des vecteurs 'liste_des_abscisses' et 'liste_des_ordonnees', mais c'est la dimension */
/* plus 1 des quatre vecteurs de coefficients renvoyes au 'RETU'... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Int,INIT(index,UNDEF));
/* Definition de l'index d'iteration. */
/*..............................................................................................................................*/
DoIn(index
,PREMIER_ELEMENT_DE_LA_FONCTION
,PRED(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION,nombre_d_echantillons))
,PasX
)
Bblock
EGAL(ITb1(coefficients_de_degre_0,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,ITb0(liste_des_ordonnees,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
);
/* */
/* C = Y(i) */
/* 0,i */
/* */
EGAL(ITb1(coefficients_de_degre_1,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,ITb0(liste_des_derivees_premieres,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
);
/* */
/* dY */
/* C = ----(i) */
/* 1,i dX */
/* */
EGAL(ITb1(coefficients_de_degre_3,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,DIVI(SOUS(ADD2(ITb0(liste_des_derivees_premieres,INDX(NEUT(index),PREMIER_ELEMENT_DE_LA_FONCTION))
,ITb0(liste_des_derivees_premieres,INDX(SUCC(index),PREMIER_ELEMENT_DE_LA_FONCTION))
)
,DOUB(DIVI(DELTA_VECTEUR(liste_des_ordonnees,SUCC(index),NEUT(index))
,DELTA_VECTEUR(liste_des_abscisses,SUCC(index),NEUT(index))
)
)
)
,EXP2(DELTA_VECTEUR(liste_des_abscisses,SUCC(index),NEUT(index)))
)
);
/* */
/* dY dY Y(i+1) - Y(i) */
/* ----(i) + ----(i+1) - 2.--------------- */
/* dX dX X(i+1) - X(i) */
/* C = ----------------------------------------- */
/* 3,i 2 */
/* [X(i+1) - X(i)] */
/* */
EGAL(ITb1(coefficients_de_degre_2,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,DIVI(SOUS(DELTA_VECTEUR(liste_des_ordonnees,SUCC(index),NEUT(index))
,MUL2(DELTA_VECTEUR(liste_des_abscisses,SUCC(index),NEUT(index))
,ADD2(ITb1(coefficients_de_degre_1,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
,MUL2(EXP2(DELTA_VECTEUR(liste_des_abscisses,SUCC(index),NEUT(index)))
,ITb1(coefficients_de_degre_3,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION))
)
)
)
)
,EXP2(DELTA_VECTEUR(liste_des_abscisses,SUCC(index),NEUT(index)))
)
);
/* */
/* 2 */
/* [Y(i+1) - Y(i)] - [X(i+1) - X(i)].{C + C .[X(i+1) - X(i)] } */
/* 1,i 3,i */
/* C = ----------------------------------------------------------------- */
/* 2,i 2 */
/* [X(i+1) - X(i)] */
/* */
Eblock
EDoI
RETU_ERROR;
Eblock
#undef DELTA_VECTEUR
#undef PREMIER_ELEMENT_DE_LA_FONCTION
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E " D E M I - S O M M E / D E M I - D I F F E R E N C E " */
/* M O N O - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
#define PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
INDEX0 \
/* Premier element du vecteur definissant sa transformee. */
BFonctionI
#define MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
MOIT(nombre_de_points_de_la_fonction_et_de_sa_transformee) \
/* La dichotomie de la transformee "somme-difference" se fait en diminuant de moitie */ \
/* le nombre d'elements de la definition, ce qui double la periode a chaque etape... */
#define PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE \
TRMU(TRPU(nombre_de_points_a_la_fin_de_la_recursivite)) \
/* Pas a utiliser pour balayer les vecteurs definissant la fonction et ses transformees. */
#define DEFINITION_DES_INDEX_GAUCHE_ET_DROITE \
DEFV(Int,INIT(index_gauche \
,ADD2(NEUT(DOUB(SOUS(coordonnee_spatiale,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE))) \
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
) \
) \
); \
DEFV(Int,INIT(index_droite \
,ADD2(ADD2(DOUB(SOUS(coordonnee_spatiale,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE)) \
,PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE \
) \
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
) \
) \
);
#define DEFINITION_DES_INDEX_DEMI_SOMME_ET_DEMI_DIFFERENCE \
DEFV(Int,INIT(index______demi_somme \
,NEUT(coordonnee_spatiale) \
) \
); \
DEFV(Int,INIT(index_demi_difference \
,ADD2(coordonnee_spatiale,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE) \
) \
);
#define FONCTION_ET_SA_TRANSFORMEE(index) \
ITb0(fonction_et_sa_transformee \
,INDX(index,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE) \
)
#define DEMI_SOMME______DES_VALEURS(coordonnee) \
IdTb1(demi_somme______des_valeurs \
,INDX(coordonnee,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE) \
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
)
#define DEMI_DIFFERENCE_DES_VALEURS(coordonnee) \
IdTb1(demi_difference_des_valeurs \
,INDX(coordonnee,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE) \
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE \
)
/* Acces aux differentes structures... */
DEFV(Common,DEFV(Float,SINT(IFsomme_difference_1D_____seuil_de_filtrage_des_demi_sommes______de_la_transformee_inverse,FZERO)));
DEFV(Common,DEFV(Float,SINT(IFsomme_difference_1D_____seuil_de_filtrage_des_demi_differences_de_la_transformee_inverse,FZERO)));
/* Parametres introduits le 20030327120555 et qui permettent de supprimer les petits */
/* coefficients (en valeur absolue) lors de la transformee inverse... */
/* */
/* ATTENTION : ces seuils sont en general dans [0,1] et non point dans [$NOIR,$BLANC]... */
DEFV(Local,DEFV(FonctionI,IFsomme_difference_1D(fonction_et_sa_transformee
,nombre_de_points_de_la_fonction_et_de_sa_transformee
,nombre_de_points_a_la_fin_de_la_recursivite
,calcul_de_la_transformee_directe
)
)
)
/* Fonction introduite le 20030324115446. */
DEFV(Argument,DEFV(Float,DTb0(fonction_et_sa_transformee)));
/* Vecteur contenant a la fois la fonction et sa transformee "somme-difference". */
DEFV(Argument,DEFV(Positive,nombre_de_points_de_la_fonction_et_de_sa_transformee));
/* Dimension du vecteur contenant la transformee de la fonction. */
DEFV(Argument,DEFV(Positive,nombre_de_points_a_la_fin_de_la_recursivite));
/* Dimension limite correspondant a la fin de la recursivite (en general */
/* vaudra 'UNITE'). */
DEFV(Argument,DEFV(Logical,calcul_de_la_transformee_directe));
/* Cet indicateur precise si l'on calcule la transformee directe ('VRAI'), */
/* ou inverse ('FAUX'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Int,INIT(frequence_spatiale,UNDEF));
/* Definition de la frequence spatiale 'u' courante. */
/*..............................................................................................................................*/
Test(IFLT(nombre_de_points_de_la_fonction_et_de_sa_transformee,nombre_de_points_a_la_fin_de_la_recursivite))
Bblock
PRINT_ERREUR("la definition de la fonction est mauvaise");
/* Ou bien, le nombre de points initial est negatif ou nul, ou bien, la */
/* fin de la recursivite n'est pas une puissance de 2... */
CODE_ERROR(ERREUR15);
Eblock
ATes
Bblock
Test(IFEQ(nombre_de_points_de_la_fonction_et_de_sa_transformee,nombre_de_points_a_la_fin_de_la_recursivite))
Bblock
/* C'est fini... */
Eblock
ATes
Bblock
/* Cas, ou la recursivite doit se poursuivre... */
DEFV(Int,INIT(coordonnee_spatiale,UNDEF));
/* Index permettant de calculer les moyennes et les differences... */
DEFV(Float,DdTb1(POINTERf
,demi_somme______des_valeurs
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,fMalo(MUL2(MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,size_Float))
)
);
DEFV(Float,DdTb1(POINTERf
,demi_difference_des_valeurs
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,fMalo(MUL2(MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,size_Float))
)
);
/* Allocation des vecteurs contenant respectivement la moyenne et la difference des valeurs. */
Test(IFNE(DOUB(MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE)
,nombre_de_points_de_la_fonction_et_de_sa_transformee
)
)
Bblock
PRINT_ERREUR("la dimension des lignes et/ou des colonnes n'est pas une puissance de 2");
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(calcul_de_la_transformee_directe))
Bblock
/* Calcul de la transformee directe : */
DoIn(coordonnee_spatiale
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,LSTX(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
)
,PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE
)
Bblock
DEFINITION_DES_INDEX_GAUCHE_ET_DROITE;
EGAL(DEMI_SOMME______DES_VALEURS(coordonnee_spatiale)
,MOYE(FONCTION_ET_SA_TRANSFORMEE(index_gauche)
,FONCTION_ET_SA_TRANSFORMEE(index_droite)
)
);
EGAL(DEMI_DIFFERENCE_DES_VALEURS(coordonnee_spatiale)
,SOYE(FONCTION_ET_SA_TRANSFORMEE(index_gauche)
,FONCTION_ET_SA_TRANSFORMEE(index_droite)
)
);
/* Calcul de la moyenne et de la difference des elements de la fonction. */
/* */
/* Soient 'G' (pour "Gauche") et 'D' (pour "Droite") deux elements successifs de la */
/* fonction. On a alors : */
/* */
/* G + D */
/* m = ------- */
/* 2 */
/* */
/* G - D */
/* d = ------- */
/* 2 */
/* */
/* 'm' et 'd' designant respectivement "demi-somme" et "demi-difference" (en fait */
/* "Moyenne" et "Difference" historiquement). On notera immediatement (ce qui sera */
/* utilise dans la transformee inverse) que : */
/* */
/* G = m + d */
/* D = m - d */
/* */
/* Le principe de cette transformee "somme-difference" est donc le suivant. Soit un */
/* vecteur V (qui sera ulterieurement une ligne ou une colonne d'image) : */
/* */
/* ------------------------------------------------- */
/* V : | G1 | D1 | G2 | D2 | G3 | D3 | ... | GN | DN | */
/* ------------------------------------------------- */
/* */
/* materialisons les couples {G(i),D(i)} (par un caractere ":") : */
/* */
/* ------------------------------------------------- */
/* V : | G1 : D1 | G2 : D2 | G3 : D3 | ... | GN : DN | */
/* ------------------------------------------------- */
/* */
/* Pour chaque couple {G,D} d'elements de ce vecteur, on calcule {m,d} et le vecteur V */
/* est reecrit : */
/* */
/* ------------------------------------------------- */
/* V : | m1 : m2 | m3 : .. : mN | d1 : d2 | d3 : .. : dN | */
/* ------------------------------------------------- */
/* \ / */
/* \________ V' ________/ */
/* */
/* */
/* */
/* ou ainsi toutes les moyennes 'm(i)' sont mises a gauche et toutes les difference 'd(i)' */
/* a droite. */
/* */
/* La procedure precedente est repetee recursivement sur le vecteur V' (qui est donc de */
/* longueur moitie de celle de V) jusqu'a un vecteur de longueur unite... */
/* */
/* Une image sera alors traitee en deux passes : une premiere concernant les lignes et une */
/* seconde concernant les colonnes... */
Eblock
EDoI
DoIn(coordonnee_spatiale
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,LSTX(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
)
,PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE
)
Bblock
DEFINITION_DES_INDEX_DEMI_SOMME_ET_DEMI_DIFFERENCE;
EGAL(FONCTION_ET_SA_TRANSFORMEE(index______demi_somme)
,DEMI_SOMME______DES_VALEURS(coordonnee_spatiale)
);
EGAL(FONCTION_ET_SA_TRANSFORMEE(index_demi_difference)
,DEMI_DIFFERENCE_DES_VALEURS(coordonnee_spatiale)
);
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
CALS(IFsomme_difference_1D(fonction_et_sa_transformee
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,nombre_de_points_a_la_fin_de_la_recursivite
,calcul_de_la_transformee_directe
)
);
/* Calcul de la transformee "somme-difference" de la fonction argument. */
Test(IL_FAUT(calcul_de_la_transformee_directe))
Bblock
Eblock
ATes
Bblock
/* Calcul de la transformee inverse : */
DoIn(coordonnee_spatiale
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,LSTX(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
)
,PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE
)
Bblock
DEFINITION_DES_INDEX_DEMI_SOMME_ET_DEMI_DIFFERENCE;
DEFV(Float,INIT(demi_somme_____,FLOT__UNDEF));
DEFV(Float,INIT(demi_difference,FLOT__UNDEF));
EGAL(demi_somme_____,FONCTION_ET_SA_TRANSFORMEE(index______demi_somme));
EGAL(demi_difference,FONCTION_ET_SA_TRANSFORMEE(index_demi_difference));
/* Moyenne et difference courantes... */
EGAL(DEMI_SOMME______DES_VALEURS(coordonnee_spatiale)
,COND(IFGE(ABSO(demi_somme_____)
,IFsomme_difference_1D_____seuil_de_filtrage_des_demi_sommes______de_la_transformee_inverse
)
,demi_somme_____
,FZERO
)
);
EGAL(DEMI_DIFFERENCE_DES_VALEURS(coordonnee_spatiale)
,COND(IFGE(ABSO(demi_difference)
,IFsomme_difference_1D_____seuil_de_filtrage_des_demi_differences_de_la_transformee_inverse
)
,demi_difference
,FZERO
)
);
/* Filtrage eventuel de la moyenne et de la difference courantes... */
/* */
/* ATTENTION : ces seuils sont en general dans [0,1] et non point dans [$NOIR,$BLANC]... */
Eblock
EDoI
DoIn(coordonnee_spatiale
,PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,LSTX(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
)
,PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE
)
Bblock
DEFINITION_DES_INDEX_GAUCHE_ET_DROITE;
EGAL(FONCTION_ET_SA_TRANSFORMEE(index_gauche)
,ADD2(DEMI_SOMME______DES_VALEURS(coordonnee_spatiale)
,DEMI_DIFFERENCE_DES_VALEURS(coordonnee_spatiale)
)
);
EGAL(FONCTION_ET_SA_TRANSFORMEE(index_droite)
,SOUS(DEMI_SOMME______DES_VALEURS(coordonnee_spatiale)
,DEMI_DIFFERENCE_DES_VALEURS(coordonnee_spatiale)
)
);
/* Calcul des elements de la fonction a partir de leurs moyennes et de leur differences. */
Eblock
EDoI
Eblock
ETes
FdTb1(demi_difference_des_valeurs
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,Float,ADRESSE_PLUS_DEFINIE
);
FdTb1(demi_somme______des_valeurs
,MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,Float,ADRESSE_PLUS_DEFINIE
);
/* Allocation des vecteurs contenant respectivement la moyenne et la difference des valeurs. */
/* */
/* Les 'ADRESSE_PLUS_DEFINIE's ont ete introduits le 20050221170441... */
Eblock
ETes
Eblock
ETes
RETU_ERROR;
Eblock
#undef DEMI_DIFFERENCE_DES_VALEURS
#undef DEMI_SOMME______DES_VALEURS
#undef FONCTION_ET_SA_TRANSFORMEE
#undef DEFINITION_DES_INDEX_DEMI_SOMME_ET_DEMI_DIFFERENCE
#undef DEFINITION_DES_INDEX_GAUCHE_ET_DROITE
#undef PAS_DES_ITERATIONS_DE_DEMI_SOMME_ET_DEMI_DIFFERENCE
#undef MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M E E " D E M I - S O M M E / D E M I - D I F F E R E N C E " */
/* B I - D I M E N S I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(Positive,SINT(IFsomme_difference_2D_____nombre_de_points_a_la_fin_de_la_recursivite__horizontale,ZERO)));
DEFV(Common,DEFV(Positive,SINT(IFsomme_difference_2D_____nombre_de_points_a_la_fin_de_la_recursivite__verticale,ZERO)));
/* Permet de generer des images suivant la methode anterieure au 20151209131512 en ce qui */
/* concerne le nombre de points a la fin de la recursivite... */
/* */
/* Je note le 20151209133751 que cela ne semble pas tres interessant, mais malgre tout, */
/* je conserve ce dispositif. Que voit-on si il est utilise ? Par exemple si on prend */
/* 64 points l'horizontale et a la verticale, la transformee de l'image Argument */
/* ('calcul_de_la_transformee_directe') est identique a l'image Argument ('imageA') sauf */
/* sur une grille 64x64 sur laquelle on trouve les 'log2(1024/64) = 4' premieres etapes */
/* de la transformation (au passage, le 1024 precedent vient de l'hypothese que l'on est */
/* en mode 'Sdu'...). */
DEFV(Common,DEFV(FonctionF,POINTERp(IFsomme_difference_2D(transformee_de_l_imageA
,imageA
,calcul_de_la_transformee_directe
)
)
)
)
/* Fonction introduite le 20030324115446. */
DEFV(Argument,DEFV(imageF,transformee_de_l_imageA));
/* Image transformee de "somme-difference" de l'image Argument. */
DEFV(Argument,DEFV(imageF,imageA));
/* Image Argument. */
DEFV(Argument,DEFV(Logical,calcul_de_la_transformee_directe));
/* Cet indicateur precise si l'on calcule la transformee directe ('VRAI'), */
/* ou inverse ('FAUX'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
BDEFV(ligneF,ligne_courante_et_sa_transformee);
/* Ligne courante et sa transformee "somme-difference"... */
BDEFV(colonneF,colonne_courante_et_sa_transformee);
/* Colonne courante et sa transformee "somme-difference"... */
/*..............................................................................................................................*/
Test(IFNE(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,PAR0(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE)))
Bblock
PRINT_ERREUR("le premier element d'un vecteur doit avoir un rang pair");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IFNE(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,Xmin)
,IFNE(PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE,Ymin)
)
)
Bblock
PRINT_ERREUR("les definitions sont incompatibles avec la methode");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IZNE(REST(dimX,pasX))
,IZNE(REST(dimY,pasY))
)
)
Bblock
PRINT_ERREUR("les pas 'pasX' et 'pasY' doivent etre aussi des puissances de 2");
/* En fait, la verification que 'dimX' et 'dimY' sont aussi des puissances */
/* de 2 n'est faite que lors de la dichotomie recursive (pour des raisons */
/* de simplicite...). */
Eblock
ATes
Bblock
Eblock
ETes
begin_colonne
Bblock
/* On transforme d'abord horizontalement : */
/* */
/* Y ^ */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* | ---------------- */
/* -|--------------------> */
/* X */
/* */
/* (ligne apres ligne). */
begin_ligne
Bblock
EGAL(LIGNE(ligne_courante_et_sa_transformee,X,Y)
,loadF_point(imageA,X,Y)
);
/* Recuperation de la ligne courante dans 'imageA' (c'est-a-dire */
/* l'image Argument), */
Eblock
end_ligne
CALS(IFsomme_difference_1D(ligne_courante_et_sa_transformee
,dimX
,MAX2(IFsomme_difference_2D_____nombre_de_points_a_la_fin_de_la_recursivite__horizontale
,TRMU(TRPU(pasX))
)
,calcul_de_la_transformee_directe
)
);
/* Et transformation "somme-difference" mono-dimensionnelle de la ligne courante... */
begin_ligne
Bblock
storeF_point(LIGNE(ligne_courante_et_sa_transformee,X,Y)
,transformee_de_l_imageA
,X,Y
);
/* Generation de la transformee "somme-difference" bi-dimensionnelle, ligne apres ligne... */
Eblock
end_ligne
Eblock
end_colonne
begin_ligne
Bblock
/* Puis, on transforme verticalement : */
/* */
/* Y ^ */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* | | | | | | | | | */
/* -|--------------------> */
/* X */
/* */
/* (colonne apres colonne). */
begin_colonne
Bblock
EGAL(COLONNE(colonne_courante_et_sa_transformee,X,Y)
,loadF_point(transformee_de_l_imageA,X,Y)
);
/* Recuperation de la colonne courante dans 'transformee_de_l_imageA' */
/* (c'est-a-dire la transformee "horizontale" de 'imageA'). */
Eblock
end_colonne
CALS(IFsomme_difference_1D(colonne_courante_et_sa_transformee
,dimY
,MAX2(IFsomme_difference_2D_____nombre_de_points_a_la_fin_de_la_recursivite__verticale
,TRMU(TRPU(pasY))
)
,calcul_de_la_transformee_directe
)
);
/* Et transformation "somme-difference" mono-dimensionnelle de la colonne courante... */
begin_colonne
Bblock
storeF_point(COLONNE(colonne_courante_et_sa_transformee,X,Y)
,transformee_de_l_imageA
,X,Y
);
/* Generation de la transformee de "somme-difference" bi-dimensionnelle, colonne */
/* apres colonne... */
Eblock
end_colonne
Eblock
end_ligne
EDEFV(colonneF,colonne_courante_et_sa_transformee);
/* Colonne courante et sa transformee "somme-difference"... */
EDEFV(ligneF,ligne_courante_et_sa_transformee);
/* Ligne courante et sa transformee "somme-difference"... */
RETIF(transformee_de_l_imageA);
Eblock
EFonctionF
#undef PREMIER_ELEMENT_DE_LA_FONCTION_ET_DE_SA_TRANSFORMEE
_______________________________________________________________________________________________________________________________________