/*************************************************************************************************************************************/
/* */
/* C A L C U L D E L A D I M E N S I O N F R A C T A L E G E N E R A L I S E E */
/* P A R E X A M E N D U V O I S I N A G E D E S P O I N T S */
/* E T P E R M E T T A N T S I M U L T A N E M E N T L ' E X T R A C T I O N D E C O N T O U R S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande calcule la dimension */
/* fractale generalisee en examinant le */
/* voisinage des points par convolution. */
/* */
/* */
/* Author of '$xci/dimension.02$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1993??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define SEUIL_D_INHIBITION \
GRIS_4 \
/* Seuil de definition de l'autorisation (>=seuil) ou d'inhibition (<seuil) du noyau. */
#define EDITER_LE_NOYAU \
FAUX \
/* Indique s'il faut editer les valeurs du noyau ('VRAI') ou pas ('FAUX'). */
#define LE_NOYAU_DE_CONVOLUTION_EST_CARRE \
VRAI \
/* Indique si le noyau de convolution est carre ('VRAI') ou circulaire ('FAUX'). */
#define NOMBRE_DE_POINTS_DU_NOYAU \
EXP2(DOUP(QUATRE)) \
/* Nombre de points du noyau. On notera qu'il est prefererable que le noyau soit symetrique */ \
/* ce qui implique que sa dimension soit le carre d'un nombre impair, auquel cas, il a un */ \
/* centre... */
#define METHODE_LINEAIRE \
VRAI \
/* Cet indicateur precise si l'on doit utiliser la methode lineaire ('VRAI') qui consiste */ \
/* a regarder les pentes des droites formees par les couples de points, ou a ajuster une */ \
/* courbe parabolique passant par les trois points calcules... */
#define NORMALISER_LE_NOMBRE_DE_POINTS_GENERALISE \
VRAI \
/* Cet indicateur precise si l'on doit normaliser le nombre de points generalise ('VRAI') */ \
/* ou bien le laisser tel quel et donc certainement non entier ('FAUX'). */
#define NORMALISER_GLOBALEMENT_LES_IMAGES_COEFFICIENTS \
VRAI \
/* Cet indicateur precise si l'on doit normaliser globalement les trois image coefficients */ \
/* 'c1', 'c2' et 'c3' ('VRAI') ou localement ('FAUX'). Cette possibilite a ete introduite */ \
/* le 20151105112345, la valeur par defaut garantissant la compatibilite anterieure. */
#define EN_VUE_D_EXTRAIRE_DES_CONTOURS \
FAUX \
/* Option destinee a assurer (lorsque sa valeur est 'VRAI') la compatibilite avec le */ \
/* fonctionnement anterieur au 20020226095028 ('v $xiio/LENA_CONT.11'). Cette compatibilite */ \
/* sera complete en utilisant les parametres suivant : */ \
/* */ \
/* contours=VRAI normaliser=FAUX eviter=-1 */ \
/* */
#define COMPATIBILITE_20070621 \
FAUX \
/* Permet de proceder a des calculs de dimension fractale compatibles avec ceux effectues */ \
/* anterieurement au 20070621101434. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/convol.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E L A D I M E N S I O N F R A C T A L E G E N E R A L I S E E */
/* P A R E X A M E N D U V O I S I N A G E D E S P O I N T S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageV),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageF),NOM_PIPE));
/* Nom de l'image a displayer. On notera que par defaut : */
/* */
/* imageV = BLANC */
/* imageF = seuil_d_inhibition */
/* */
DEFV(CHAR,INIC(POINTERc(nom_imageR2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageR1),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageR0),NOM_PIPE));
/* Nom des trois images Resultat donnant les coefficients 'c1', 'c2' et 'c3'. */
DEFV(Logical,INIT(le_noyau_de_convolution_est_carre,LE_NOYAU_DE_CONVOLUTION_EST_CARRE));
/* Indique si le noyau de convolution est carre ('VRAI') ou circulaire ('FAUX'). */
DEFV(Logical,DTb1(niveaux_a_traiter,COULEURS));
/* Definit les niveaux sur lesquels on doit faire la convolution par 'Pconvolution()'. */
DEFV(Logical,DTb1(niveaux_cumulables,COULEURS));
/* Definit les niveaux cumulables lors du calcul de 'Pconvolution_____cumul_courant'. */
DEFV(genere_p,INIT(seuil_d_inhibition,SEUIL_D_INHIBITION));
/* Seuil de definition de l'autorisation (>=seuil) ou d'inhibition (<seuil) du noyau. */
DEFV(Int,INIT(nombre_de_points,NOMBRE_DE_POINTS_DU_NOYAU));
/* Nombre de points du noyau. On notera qu'il est prefererable que le noyau soit symetrique */
/* ce qui implique que sa dimension soit le carre d'un nombre impair, auquel cas, il a un */
/* centre... */
DEFV(Float,DTb1(noyau,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION));
/* Noyau de la convolution, */
DEFV(Logical,DTb1(inhibition_du_noyau,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION));
/* Et sa liste d'activite. */
DEFV(Int,INIT(index,UNDEF));
/* Index d'initialisation du noyau. */
DEFV(Logical,INIT(editer_le_noyau,EDITER_LE_NOYAU));
/* Indique s'il faut editer les valeurs du noyau ('VRAI') ou pas ('FAUX'). */
DEFV(Logical,INIT(methode_lineaire,METHODE_LINEAIRE));
/* Cet indicateur precise si l'on doit utiliser la methode lineaire ('VRAI') qui consiste */
/* a regarder les pentes des droites formees par les couples de points, ou a ajuster une */
/* courbe parabolique passant par les trois points calcules... */
DEFV(Logical,INIT(normaliser_le_nombre_de_points_generalise,NORMALISER_LE_NOMBRE_DE_POINTS_GENERALISE));
/* Cet indicateur precise si l'on doit normaliser le nombre de points generalise ('VRAI') */
/* ou bien le laisser tel quel et donc certainement non entier ('FAUX'). */
DEFV(Logical,INIT(normaliser_globalement_les_images_coefficients,NORMALISER_GLOBALEMENT_LES_IMAGES_COEFFICIENTS));
/* Cet indicateur precise si l'on doit normaliser globalement les trois image coefficients */
/* 'c1', 'c2' et 'c3' ('VRAI') ou localement ('FAUX'). Cette possibilite a ete introduite */
/* le 20151105112345, la valeur par defaut garantissant la compatibilite anterieure. */
DEFV(Logical,INIT(en_vue_d_extraire_des_contours,EN_VUE_D_EXTRAIRE_DES_CONTOURS));
/* Option destinee a assurer (lorsque sa valeur est 'VRAI') la compatibilite avec le */
/* fonctionnement anterieur au 20020226095028 ('v $xiio/LENA_CONT.11'). Cette compatibilite */
/* sera complete en utilisant les parametres suivant : */
/* */
/* contours=VRAI normaliser=FAUX eviter=-1 */
/* */
DEFV(genere_Float,INIT(minimum_du_coefficient_de_d2,F_INFINI));
DEFV(genere_Float,INIT(maximum_du_coefficient_de_d2,F_MOINS_L_INFINI));
/* Extrema du coefficient 'c2'. */
DEFV(genere_Float,INIT(minimum_du_coefficient_de_d1,F_INFINI));
DEFV(genere_Float,INIT(maximum_du_coefficient_de_d1,F_MOINS_L_INFINI));
/* Extrema du coefficient 'c1'. */
DEFV(genere_Float,INIT(minimum_du_coefficient_de_d0,F_INFINI));
DEFV(genere_Float,INIT(maximum_du_coefficient_de_d0,F_MOINS_L_INFINI));
/* Extrema du coefficient 'c0'. */
DEFV(Logical,INIT(compatibilite_20070621,COMPATIBILITE_20070621));
/* Permet de proceder a des calculs de dimension fractale compatibles avec ceux effectues */
/* anterieurement au 20070621101434. */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20070621=",compatibilite_20070621);
GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("imageV=""V=",nom_imageV);
GET_ARGUMENT_C("imageF=""F=",nom_imageF);
GET_ARGUMENT_C("p3=""imageR2=""d2=""c2=""R2=",nom_imageR2);
GET_ARGUMENT_C("p2=""imageR1=""d1=""c1=""R1=",nom_imageR1);
GET_ARGUMENT_C("p1=""imageR0=""d0=""c0=""R0=",nom_imageR0);
GET_ARGUMENT_L("standard=",les_images_sont_standards);
GET_ARGUMENT_P("seuil=",seuil_d_inhibition);
GET_ARGUMENT_L("editer=",editer_le_noyau);
GET_ARGUMENT_L("noyau_carre=""ncarre=",le_noyau_de_convolution_est_carre);
/* Le 20060118092653, "carre=" a ete remplace par "noyau_carre=" et "ncarre=" (risque de */
/* double definition...). */
GET_ARGUMENT_N("noyau_circulaire=""ncirculaire=",le_noyau_de_convolution_est_carre);
/* Ces deux parametres furent introduits le 20071003113851... */
GET_ARGUMENT_I("sautC=""saut=",Pconvolution_____nombre_de_points_sautes);
GET_ARGUMENT_I("sautN=",CALCUL_D_UN_NOYAU_DE_CONVOLUTION_VARIABLE_____Pnoyau_nombre_de_points_sautes);
/* Option introduite le 20050225214158... */
GET_ARGUMENT_L("circulaire=",Pconvolution_____parcourir_circulairement_les_spirales_carrees);
/* Option introduite le 20040703110213... */
GET_ARGUMENT_L("circulaire_optimale="
,Pconvolution_____adapter_le_nombre_de_points_lors_du_parcours_circulaire_des_spirales_carrees
);
/* Option introduite le 20061224122302... */
GET_ARGUMENTS2_I("spirale_pasX=""spX=""spx="
,SPIRALE_DEPLACEMENT_____amplitude_horizontale
,SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS_____amplitude_horizontale
);
GET_ARGUMENTS2_I("spirale_pasY=""spY=""spy="
,SPIRALE_DEPLACEMENT_____amplitude_verticale__
,SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS_____amplitude_verticale__
);
/* Options introduites le 20151109150609... */
GET_ARGUMENT_I("points=""p=",nombre_de_points);
GET_ARGUMENT_L("lineaire=",methode_lineaire);
GET_ARGUMENT_L("normaliser_nombre_points=""normaliser=",normaliser_le_nombre_de_points_generalise);
GET_ARGUMENT_L("contours=",en_vue_d_extraire_des_contours);
GET_ARGUMENT_F("eviter=",IFnombre_de_points_generalise_dans_un_voisinage_____evitement_des_zones_noires);
GET_ARGUMENT_L("normaliser_globalement_coefficients=""ngc=",normaliser_globalement_les_images_coefficients);
GET_ARGUMENT_N("normaliser_localement=""nlc=",normaliser_globalement_les_images_coefficients);
GET_ARGUMENT_F("ponderation_cumul=""pc="
,IFnombre_de_points_generalise_dans_un_voisinage_____ponderation_du_cumul_courant____________
);
GET_ARGUMENT_F("ponderation_dispersion=""pd="
,IFnombre_de_points_generalise_dans_un_voisinage_____ponderation_de_la_dispersion_des_niveaux
);
GET_ARGUMENT_F("ponderation_dispersion_minimum=""pdmin="
,Pconvolution_____dispersion_des_niveaux_sur_la_spirale__ponderation__minimum
);
GET_ARGUMENT_F("ponderation_dispersion_moyenne=""pdmoy="
,Pconvolution_____dispersion_des_niveaux_sur_la_spirale__ponderation__moyenne
);
GET_ARGUMENT_F("ponderation_dispersion_maximum=""pdmax="
,Pconvolution_____dispersion_des_niveaux_sur_la_spirale__ponderation__maximum
);
GET_ARGUMENT_F("ponderation_dispersion_translation=""pdt="
,Pconvolution_____dispersion_des_niveaux_sur_la_spirale__ponderation__translation
);
/* Options introduites le 20151105105356 et completees le 20151105112345 avec la */
/* normalisation des coefficients... */
/* */
/* Les options de ponderation des composantes de normalisation de la dispersion ont */
/* ete introduites le 20151112093708... */
GET_ARGUMENT_L("message_extrema=""me=",Ifloat_std_____editer_le_message_d_attention_relatif_aux_extrema);
/* Pour 'v $xrC/CompressionDeCompression_CompressionSegmentsFractalsHomogenes.01$vv$Z' */
/* cette option a ete introduite le 20160708105527... */
)
);
EGAL(IFnombre_de_points_generalise_dans_un_voisinage_____evitement_des_zones_noires
,COND(IL_FAUT(compatibilite_20070621)
,NEUT(POUR_OBTENIR_UN_LOGARITHME_POSITIF)
,FZERO
)
);
/* Pour compenser via 'anti_translation_des_valeurs' la translation effectuee avec */
/* 'POUR_OBTENIR_UN_LOGARITHME_POSITIF' dans la fonction */
/* 'v $xiii/di_image$FON IFdynamique_logarithmique_sans_translation_dynamique'. */
/* */
/* Le 20070621101434 je note donc quelque chose qui me parait faux. En effet, lors du calcul */
/* de 'v $xiii/di_image$FON IFdynamique_logarithmique_sans_translation_dynamique', on fait */
/* en chaque point {X,Y} le calcul suivant : */
/* */
/* loadF_point(imageA,X,Y) */
/* - IFnombre_de_points_generalise_dans_un_voisinage_____evitement_des_zones_noires */
/* + POUR_OBTENIR_UN_LOGARITHME_POSITIF */
/* */
/* soit : */
/* */
/* 0 */
/* loadF_point(imageA,X,Y) - anti_translation_des_valeurs + e */
/* */
/* soit encore : */
/* */
/* loadF_point(imageA,X,Y) - anti_translation_des_valeurs + 1 */
/* */
/* Pour obtenir des logarithmes positifs ou nuls, il faut donc evidemment que : */
/* */
/* anti_translation_des_valeurs = 0 */
/* */
/* d'ou le 'FZERO' ci-dessus... */
/* */
/* On notera que cela ne s'etait pas vu plus tot (en particulier lors de la mise au point */
/* de ce programme 'v $xci/dimension.02$K') a cause du fait que la validation des images */
/* flottantes ('v $xiii/files$FON VERIFICATION_HEURISTIQUE_DES_genere_Float') n'a ete */
/* introduite que le 20030211085553 alors que 'v $xci/dimension.02$K' est de 19930000000000 .*/
Test(IL_FAUT(methode_lineaire))
Bblock
Eblock
ATes
Bblock
EGAL(IFdynamique_logarithmique_sans_translation_dynamique_____moins_l_infini,F_MOINS_LE_PETIT_INFINI);
/* Afin d'eviter l'apparition de l'infini lorsque 'IL_NE_FAUT_PAS(methode_lineaire)' */
/* (introduit le 20020225155414). */
Eblock
ETes
CALi(Inoir(ImageA5));
CALi(Inoir(ImageA6));
CALi(Inoir(ImageA7));
/* Initialisation de l'image Resultat. */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
EGAL(ITb1(niveaux_a_traiter,INDX(niveau,NOIR)),VRAI);
EGAL(ITb1(niveaux_cumulables,INDX(niveau,NOIR)),VRAI);
/* Initialisation telle que tous les niveaux soient a la fois "traitables" et "cumulables". */
Eblock
EBoI
Test(IFET(IFNE_chaine(nom_imageV,NOM_PIPE),IFNE_chaine(nom_imageF,NOM_PIPE)))
Bblock
DEFV(pointF_2D,centre_de_la_spirale_de_definition_du_noyau);
INITIALISATION_POINT_2D(centre_de_la_spirale_de_definition_du_noyau
,_____cNORMALISE_OX(Xcentre)
,_____cNORMALISE_OY(Ycentre)
);
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA3,nom_imageV))))
Bblock
Eblock
ATes
Bblock
CALi(Iblanc(ImageA3));
/* En cas d'erreur de chargement de l'image "Valeur", on force le BLANC... */
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA4,nom_imageF))))
Bblock
Eblock
ATes
Bblock
CALi(Iinitialisation(ImageA4,seuil_d_inhibition));
/* En cas d'erreur de chargement de l'image "Forme", on force le seuil d'inhibition... */
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALS(Igeneration_d_un_noyau_de_convolution(noyau
,inhibition_du_noyau
,nombre_de_points
,ADRESSE(centre_de_la_spirale_de_definition_du_noyau)
,CALCUL_D_UN_NOYAU_DE_CONVOLUTION_VARIABLE_____Pnoyau_nombre_de_points_sautes
,ImageA3
,ImageA4
,seuil_d_inhibition
)
);
/* Enfin, generation du noyau de convolution en fonction des images (ImageA3,ImageA4). */
/* */
/* ATTENTION, on consultera avec soin les commentaires contenus dans 'v $xiii/di_image$FON' */
/* relatifs a la fonction 'Igeneration_d_un_noyau_de_convolution(...)' au sujet des rapports */
/* entre la taille des images et la "forme" des noyaux... */
Eblock
ATes
Bblock
Test(IFLE(nombre_de_points,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION))
Bblock
DoIn(index,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points),I)
Bblock
NOYAU(index,FU);
/* Initialisation du noyau de convolution. */
Eblock
EDoI
Eblock
ATes
Bblock
PRINT_ERREUR("la taille demandee pour le noyau de convolution est incompatible avec les definitions");
EGAL(nombre_de_points,NOMBRE_DE_POINTS_DU_NOYAU);
CAL1(Prer1("(la valeur %d par defaut est forcee)\n",nombre_de_points));
/* Introduit le 20111031140938 car, en effet, manquait cruellement... */
Eblock
ETes
Eblock
ETes
Test(IL_FAUT(editer_le_noyau))
Bblock
Test(IFLE(nombre_de_points,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION))
Bblock
DoIn(index,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points),I)
Bblock
CAL3(Prme3("noyau(%d)=%g (actif=%s)\n"
,index
,ITb1(noyau,INDX(index,PREMIER_POINT))
,ETAT_LOGIQUE(ITb1(inhibition_du_noyau,INDX(index,PREMIER_POINT)))
)
);
Eblock
EDoI
Eblock
ATes
Bblock
PRINT_ERREUR("la taille demandee pour le noyau de convolution est incompatible avec les definitions");
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageA))))
/* Chargement de l'image dont on veut calculer la dimension fractale. */
Bblock
BDEFV(imageF,coefficient_de_d2_ou_pente_p3);
BDEFV(imageF,coefficient_de_d1_ou_pente_p2);
BDEFV(imageF,coefficient_de_d0_ou_pente_p1);
/* Images flottantes contenant les trois coefficient permettant de verifier la presence */
/* d'une "bonne" dimension fractale. */
CALi(IFinitialisation(coefficient_de_d2_ou_pente_p3,FZERO));
CALi(IFinitialisation(coefficient_de_d1_ou_pente_p2,FZERO));
CALi(IFinitialisation(coefficient_de_d0_ou_pente_p1,FZERO));
/* Nettoyage... */
CALS(IFdimension_fractale_convolution(coefficient_de_d2_ou_pente_p3
,coefficient_de_d1_ou_pente_p2
,coefficient_de_d0_ou_pente_p1
,ImageA
,niveaux_a_traiter,niveaux_cumulables
,nombre_de_points
,noyau,inhibition_du_noyau
,methode_lineaire
,normaliser_le_nombre_de_points_generalise
,en_vue_d_extraire_des_contours
)
);
/* Calcul des trois pentes 'p1', 'p2' et 'p3' ou des trois coefficients 'c2, 'c1' et 'c0' */
/* par convolution. */
Test(EST_VRAI(les_images_sont_standards))
Bblock
DEFV(genere_Float,INIT(minimum_global_des_coefficients_de_d2_d1_d0,FLOT__NIVEAU_UNDEF));
DEFV(genere_Float,INIT(maximum_global_des_coefficients_de_d2_d1_d0,FLOT__NIVEAU_UNDEF));
CALS(IFnivo_extrema(coefficient_de_d2_ou_pente_p3
,ADRESSE(minimum_du_coefficient_de_d2)
,ADRESSE(maximum_du_coefficient_de_d2)
)
);
CALS(IFnivo_extrema(coefficient_de_d1_ou_pente_p2
,ADRESSE(minimum_du_coefficient_de_d1)
,ADRESSE(maximum_du_coefficient_de_d1)
)
);
CALS(IFnivo_extrema(coefficient_de_d0_ou_pente_p1
,ADRESSE(minimum_du_coefficient_de_d0)
,ADRESSE(maximum_du_coefficient_de_d0)
)
);
/* Calcul des extrema des trois coefficients 'c2, 'c1' et 'c0'. */
EGAL(minimum_global_des_coefficients_de_d2_d1_d0
,MIN3(minimum_du_coefficient_de_d2,minimum_du_coefficient_de_d1,minimum_du_coefficient_de_d0)
);
EGAL(maximum_global_des_coefficients_de_d2_d1_d0
,MAX3(maximum_du_coefficient_de_d2,maximum_du_coefficient_de_d1,maximum_du_coefficient_de_d0)
);
CALS(Ifloat_std(ImageA7
,coefficient_de_d2_ou_pente_p3
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,minimum_global_des_coefficients_de_d2_d1_d0
,minimum_du_coefficient_de_d2
)
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,maximum_global_des_coefficients_de_d2_d1_d0
,maximum_du_coefficient_de_d2
)
)
);
CALS(Ifloat_std(ImageA6
,coefficient_de_d1_ou_pente_p2
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,minimum_global_des_coefficients_de_d2_d1_d0
,minimum_du_coefficient_de_d1
)
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,maximum_global_des_coefficients_de_d2_d1_d0
,maximum_du_coefficient_de_d1
)
)
);
CALS(Ifloat_std(ImageA5
,coefficient_de_d0_ou_pente_p1
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,minimum_global_des_coefficients_de_d2_d1_d0
,minimum_du_coefficient_de_d0
)
,COND(IL_FAUT(normaliser_globalement_les_images_coefficients)
,maximum_global_des_coefficients_de_d2_d1_d0
,maximum_du_coefficient_de_d0
)
)
);
/* Renormalisation... */
Eblock
ATes
Bblock
Eblock
ETes
CALi(gIupdate_image(les_images_sont_standards,nom_imageR2,ImageA7,coefficient_de_d2_ou_pente_p3));
CALi(gIupdate_image(les_images_sont_standards,nom_imageR1,ImageA6,coefficient_de_d1_ou_pente_p2));
CALi(gIupdate_image(les_images_sont_standards,nom_imageR0,ImageA5,coefficient_de_d0_ou_pente_p1));
/* L'image 'nom_imageR2' (par exemple) pourra etre utilisee pour extraire les contours de */
/* 'nom_imageA' a condition de lui faire subir un : */
/* */
/* $xci/passe_bande$X inf=$NOIR sup=80 ... */
/* */
/* suivi d'un : */
/* */
/* $xci/seuil$X ... */
/* */
/* Le 20070621104338, je note que lorsque la demande d'aide a l'extraction de contours */
/* n'est pas faite (ce qui est le cas par defaut...), l'image 'nom_imageR2' semble donner */
/* par son maximum (si "standard=FAUX"), la dimension fractale de 'nom_imageA'... */
EDEFV(imageF,coefficient_de_d0_ou_pente_p1);
EDEFV(imageF,coefficient_de_d1_ou_pente_p2);
EDEFV(imageF,coefficient_de_d2_ou_pente_p3);
/* Images flottantes contenant les trois coefficient permettant de verifier la presence */
/* d'une "bonne" dimension fractale. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
RETU_Commande;
Eblock
ECommande