_______________________________________________________________________________________________________________________________________
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E B A S E D E C A L C U L D ' U N S C A L A I R E T Y P I Q U E : */
/* */
/* */
/* Definition : */
/* */
/* Ce fichier contient toutes les fonctions */
/* de base de calcul d'un scalaire typique d'une */
/* images raster, quelle que soit la definition. */
/* */
/* */
/* Author of '$xiii/scalaires$FON' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19870000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S N I V E A U X D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(Inivo_extrema_____inverser_l_ordre_de_parcours_des_points,FAUX)));
/* Permet d'utiliser l'ordre {Xmax,Ymax} -- > {Xmin,Ymin} a la place de l'ordre standard */
/* {Xmin,Ymin} -- > {Xmax,Ymax}. Introduit le 20000331103651. On notera au passage que */
/* l'ordre standard permet, par exemple, de recuperer le dernier poinr 'BLANC' d'une */
/* image, alors que l'ordre inverse donnera le premier... */
DEFV(Common,DEFV(genere_p,INIT(Inivo_extrema_____niveau_minimum,NIVEAU_UNDEF)));
DEFV(Common,DEFV(Float,INIT(Inivo_extrema_____cumul_des_niveaux,FLOT__UNDEF)));
DEFV(Common,DEFV(genere_p,INIT(Inivo_extrema_____niveau_moyen,NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_p,INIT(Inivo_extrema_____niveau_maximum,NIVEAU_UNDEF)));
/* Niveau moyen mesure lors de chaque passage dans 'Inivo_extrema(...)'. */
DEFV(Common,DEFV(FonctionI,Inivo_extrema(imageA
,ARGUMENT_POINTEUR(nivo_minimum)
,ARGUMENT_POINTERs(point_minimum)
,ARGUMENT_POINTEUR(nivo_maximum)
,ARGUMENT_POINTERs(point_maximum)
)
)
)
DEFV(Argument,DEFV(image,imageA));
/* Image Argument. */
DEFV(Argument,DEFV(genere_p,POINTEUR(nivo_minimum)));
/* Pointeur (&) sur la valeur du minimum rencontre dans l'image argument. */
DEFV(Argument,DEFV(pointF_2D,POINTERs(point_minimum)));
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier minima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
DEFV(Argument,DEFV(genere_p,POINTEUR(nivo_maximum)));
/* Pointeur (&) sur la valeur du maximum rencontre dans l'image argument. */
DEFV(Argument,DEFV(pointF_2D,POINTERs(point_maximum)));
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier maxima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
BDEFV(image,imageM1);
/* Image de Manoeuvre 1, */
BDEFV(image,imageM2);
/* Image de Manoeuvre 2. */
DEFV(genere_p,INIT(niveau_courant,NIVEAU_UNDEF));
/* Variable de manoeuvre (valeur du point courant). */
DEFV(Float,INIT(cumul_des_niveaux,FZERO));
/* Cumul des niveaux rencontres... */
/*..............................................................................................................................*/
Test(IL_FAUT(Inivo_extrema_____inverser_l_ordre_de_parcours_des_points))
Bblock
CALS(Ix_symetrie(imageM1,imageA));
CALS(Iy_symetrie(imageM2,imageM1));
/* Cas ou l'ordre inverse ({Xmax,Ymax} -- > {Xmin,Ymin}) doit etre utilise. */
Eblock
ATes
Bblock
CALS(Imove(imageM2,imageA));
/* Cas ou l'ordre standard ({Xmin,Ymin} -- > {Xmax,Ymax}) doit etre utilise. */
Eblock
ETes
EGAL(INDIRECT(nivo_minimum),BLANC);
/* Initialisation du minimum sur la plus grande valeur possible pour un niveau standard. */
/* On notera que l'on ne peut, bien entendu, utiliser 'INFINI' etant donne le type */
/* 'genere_p' de 'nivo_minimum'... */
EGAL(INDIRECT(nivo_maximum),NOIR);
/* Initialisation du maximum sur la plus petite valeur possible pour un niveau standard. */
/* On notera que l'on ne peut, bien entendu, utiliser 'MOINS_L_INFINI' etant donne le type */
/* 'genere_p' de 'nivo_maximum'... */
begin_image
Bblock
EGAL(niveau_courant,load_point(imageM2,X,Y));
/* Recuperation du niveau courant en {X,Y}. */
INCR(cumul_des_niveaux,FLOT(niveau_courant));
/* Cumul des niveaux... */
Test(IFGE(INDIRECT(nivo_minimum),niveau_courant))
/* On notera l'utilisation de 'IFGE(...)' et non pas de 'IFGT(...)' a cause du fait que */
/* 'nivo_minimum' est initialise avec 'BLANC', c'est-a-dire un niveau possible pour le */
/* 'niveau_courant'... */
Bblock
EGAL(INDIRECT(nivo_minimum),niveau_courant);
EGAL(ASI1(point_minimum,x),_____cNORMALISE_OX(X));
EGAL(ASI1(point_minimum,y),_____cNORMALISE_OY(Y));
/* Memorisation du dernier minimum rencontre. */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFLE(INDIRECT(nivo_maximum),niveau_courant))
/* On notera l'utilisation de 'IFLE(...)' et non pas de 'IFLT(...)' a cause du fait que */
/* 'nivo_minimum' est initialise avec 'BLANC', c'est-a-dire un niveau possible pour le */
/* 'niveau_courant'... */
Bblock
EGAL(INDIRECT(nivo_maximum),niveau_courant);
EGAL(ASI1(point_maximum,x),_____cNORMALISE_OX(X));
EGAL(ASI1(point_maximum,y),_____cNORMALISE_OY(Y));
/* Memorisation du dernier maximum rencontre. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_image
EGAL(Inivo_extrema_____niveau_minimum,INDIRECT(nivo_minimum));
EGAL(Inivo_extrema_____cumul_des_niveaux,cumul_des_niveaux);
EGAL(Inivo_extrema_____niveau_moyen,GENP(DIVI(cumul_des_niveaux,FLOT(dimXY))));
EGAL(Inivo_extrema_____niveau_maximum,INDIRECT(nivo_maximum));
/* Calcul du niveau moyen rencontre... */
EDEFV(image,imageM2);
/* Image de Manoeuvre 2, */
EDEFV(image,imageM1);
/* Image de Manoeuvre 1. */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M I N I M U M D E S N I V E A U X D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionP
DEFV(Common,DEFV(FonctionP,Inivo_minimum(imageA)))
DEFV(Argument,DEFV(image,imageA));
/* Image argument. */
/* la valeur de la fonction est le minimum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_p,INIT(nivo_minimum,NIVEAU_UNDEF));
/* Minimum des niveaux d'une image. */
DEFV(pointF_2D,point_minimum);
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier minima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
DEFV(genere_p,INIT(nivo_maximum,NIVEAU_UNDEF));
/* Maximum des niveaux d'une image. */
DEFV(pointF_2D,point_maximum);
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier maxima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
/*..............................................................................................................................*/
CALS(Inivo_extrema(imageA
,ADRESSE(nivo_minimum),ADRESSE(point_minimum)
,ADRESSE(nivo_maximum),ADRESSE(point_maximum)
)
);
/* Recherche des extrema. */
RETU(nivo_minimum);
/* Renvoi du minimum uniquement. */
Eblock
EFonctionP
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M A X I M U M D E S N I V E A U X D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionP
DEFV(Common,DEFV(FonctionP,Inivo_maximum(imageA)))
DEFV(Argument,DEFV(image,imageA));
/* Image argument. */
/* la valeur de la fonction est le maximum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_p,INIT(nivo_minimum,NIVEAU_UNDEF));
/* Minimum des niveaux d'une image. */
DEFV(pointF_2D,point_minimum);
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier minima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
DEFV(genere_p,INIT(nivo_maximum,NIVEAU_UNDEF));
/* Maximum des niveaux d'une image. */
DEFV(pointF_2D,point_maximum);
/* Donne au retour les coordonnees {X,Y} dans [0,1[ du dernier maxima (au cas ou il y */
/* en aurait plusieurs...) rencontre. */
/*..............................................................................................................................*/
CALS(Inivo_extrema(imageA
,ADRESSE(nivo_minimum),ADRESSE(point_minimum)
,ADRESSE(nivo_maximum),ADRESSE(point_maximum)
)
);
/* Recherche des extrema. */
RETU(nivo_maximum);
/* Renvoi du maximum uniquement. */
Eblock
EFonctionP
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IFnivo_extrema_avec_exclusion(imageA
,ARGUMENT_POINTEUR(nivo_minimum)
,ARGUMENT_POINTEUR(nivo_maximum)
,borne_inferieure
,borne_superieure
)
)
)
/* Fonction introduite le 20050418112622 pour etre utilisee dans la procedure */
/* 'v $xiii/Images$DEF TRAITEMENT_SPECIFIQUE_DES_IMAGES_DE_TYPE_Z_Buffer'... */
DEFV(Argument,DEFV(imageF,imageA));
/* Image flottante Argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_minimum)));
/* Pointeur sur la valeur du minimum rencontre dans l'image flottante argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_maximum)));
/* Pointeur sur la valeur du maximum rencontre dans l'image flottante argument. */
DEFV(Argument,DEFV(genere_Float,borne_inferieure));
DEFV(Argument,DEFV(genere_Float,borne_superieure));
/* Les valeurs hors de [borne_inferieure,borne_superieure] seront exclues de cette */
/* recherche... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(genere_Float,INIT(niveau_minimum_courant,F_INFINI));
DEFV(genere_Float,INIT(niveau_maximum_courant,F_MOINS_L_INFINI));
/* Extrema courant... */
/*..............................................................................................................................*/
begin_image
Bblock
DEFV(genere_Float,INIT(niveau_courant,loadF_point(imageA,X,Y)));
/* Valeur du point courant... */
Test(INCLff(niveau_courant,borne_inferieure,borne_superieure))
Bblock
EGAL(niveau_minimum_courant,MIN2(niveau_minimum_courant,niveau_courant));
EGAL(niveau_maximum_courant,MAX2(niveau_maximum_courant,niveau_courant));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_image
EGAL(INDIRECT(nivo_minimum),niveau_minimum_courant);
EGAL(INDIRECT(nivo_maximum),niveau_maximum_courant);
/* Diverses mesures... */
RETU_ERROR;
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Float,SINT(IFnivo_extrema_____translation_du_minimum,FZERO)));
DEFV(Common,DEFV(Float,SINT(IFnivo_extrema_____translation_du_maximum,FZERO)));
/* Introduit le 20180513112804 pour 'v $xiirf/.FRC3.21.1.2.$U m..imum_translation'... */
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_minimum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_minimum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(Logical,SINT(IFnivo_extrema_____cumul_valide_des_niveaux,LUNDEF)));
DEFV(Common,DEFV(Float,INIT(IFnivo_extrema_____cumul_des_niveaux,FLOT__UNDEF)));
DEFV(Common,DEFV(Float,INIT(IFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FLOT__UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_moyen,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_moyen_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_maximum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_maximum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
/* Diverses mesures lors de chaque passage dans 'IFnivo_extrema(...)'. */
/* */
/* Les '*imum_en_valeur_absolue_dans_IFnivo_extrema' ont ete introduits le 20030930114834 */
/* pour etre utilise dans 'v $xiii/files$FON IFnivo_extrema'... */
DEFV(Common,DEFV(Logical,SINT(IFnivo_extrema_____calculer_le_minimum_secondaire,FAUX)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_minimum_secondaire,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(Logical,SINT(IFnivo_extrema_____calculer_le_maximum_secondaire,FAUX)));
DEFV(Common,DEFV(genere_Float,INIT(IFnivo_extrema_____niveau_maximum_secondaire,FLOT__NIVEAU_UNDEF)));
/* Recherche des extrema secondaires (introduites le 20091212204602), c'est-a-dire ceux */
/* qui sont les extrema en ayant supprime les extrema "reels" (dits "primaires")... */
/* Cela fut introduit principalement pour connaitre le minimum (donc "secondaire") du */
/* 'Z_Buffer' dont une partie contient 'Z_Buffer_____valeur_initiale' (qui est le minimum */
/* "primaire" mais qui n'est d'aucune utilite pour renormaliser 'Z_Buffer'). */
DEFV(Common,DEFV(FonctionI,IFnivo_extrema(imageA,ARGUMENT_POINTEUR(nivo_minimum),ARGUMENT_POINTEUR(nivo_maximum))))
/* Le 20030210173332, cette fonction a ete refencee dans 'IloadF_image(...)' (voir */
/* 'v $xiii/files$FON IloadF_image_____valider_les_genere_Float'). On n'oubliera pas a */
/* ce propos que les nombres flottants des 'SYSTEME_APC' ne sont pas compatibles, en */
/* general, avec les autres SYSTEMEs, d'ou cette possible verification... */
DEFV(Argument,DEFV(imageF,imageA));
/* Image flottante Argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_minimum)));
/* Pointeur sur la valeur du minimum rencontre dans l'image flottante argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_maximum)));
/* Pointeur sur la valeur du maximum rencontre dans l'image flottante argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
EGAL(IFnivo_extrema_____niveau_minimum,F_INFINI);
EGAL(IFnivo_extrema_____niveau_minimum_en_valeur_absolue,F_INFINI);
/* Initialisation du minimum sur une forte valeur positive. */
EGAL(IFnivo_extrema_____niveau_maximum,F_MOINS_L_INFINI);
EGAL(IFnivo_extrema_____niveau_maximum_en_valeur_absolue,F_MOINS_L_INFINI);
/* Initialisation du maximum sur une forte valeur negative. */
EGAL(IFnivo_extrema_____cumul_valide_des_niveaux,VRAI);
EGAL(IFnivo_extrema_____cumul_des_niveaux,FZERO);
EGAL(IFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FZERO);
/* Initialisation du cumul des niveaux rencontres... */
begin_image
Bblock
DEFV(genere_Float,INIT(niveau_courant,loadF_point(imageA,X,Y)));
DEFV(genere_Float,INIT(niveau_courant_en_valeur_absolue,FLOT__NIVEAU_UNDEF));
/* Valeur du point courant et sa valeur absolue... */
EGAL(niveau_courant_en_valeur_absolue,ABSO(niveau_courant));
/* Valeur absolue du niveau courant en {X,Y}. */
Test(IFINoo(niveau_courant,F_MOINS_LE_PETIT_INFINI,F_PETIT_INFINI))
/* Ce test a ete introduit le 20040408095536 a cause de 'SYSTEME_SG'... */
Bblock
INCR(IFnivo_extrema_____cumul_des_niveaux,niveau_courant);
INCR(IFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,niveau_courant_en_valeur_absolue);
/* Cumul des niveaux... */
Eblock
ATes
Bblock
EGAL(IFnivo_extrema_____cumul_valide_des_niveaux,FAUX);
Eblock
ETes
EGAL(IFnivo_extrema_____niveau_minimum
,MIN2(IFnivo_extrema_____niveau_minimum,niveau_courant)
);
EGAL(IFnivo_extrema_____niveau_minimum_en_valeur_absolue
,MIN2(IFnivo_extrema_____niveau_minimum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
EGAL(IFnivo_extrema_____niveau_maximum
,MAX2(IFnivo_extrema_____niveau_maximum,niveau_courant)
);
EGAL(IFnivo_extrema_____niveau_maximum_en_valeur_absolue
,MAX2(IFnivo_extrema_____niveau_maximum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
Eblock
end_image
EGAL(IFnivo_extrema_____niveau_moyen
,DIVI(IFnivo_extrema_____cumul_des_niveaux,FLOT(dimXY))
);
EGAL(IFnivo_extrema_____niveau_moyen_en_valeur_absolue
,DIVI(IFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FLOT(dimXY))
);
INCR(IFnivo_extrema_____niveau_minimum,IFnivo_extrema_____translation_du_minimum);
INCR(IFnivo_extrema_____niveau_maximum,IFnivo_extrema_____translation_du_maximum);
/* Introduite le 20180513112804 pour 'v $xiirf/.FRC3.21.1.2.$U m..imum_translation'... */
EGAL(INDIRECT(nivo_minimum),IFnivo_extrema_____niveau_minimum);
EGAL(INDIRECT(nivo_maximum),IFnivo_extrema_____niveau_maximum);
/* Diverses mesures... */
Test(IFOU(IL_FAUT(IFnivo_extrema_____calculer_le_minimum_secondaire)
,IL_FAUT(IFnivo_extrema_____calculer_le_maximum_secondaire)
)
)
/* Ce test a ete introduit le 20091212204602... */
Bblock
EGAL(IFnivo_extrema_____niveau_minimum_secondaire,F_INFINI);
EGAL(IFnivo_extrema_____niveau_maximum_secondaire,F_MOINS_L_INFINI);
begin_image
Bblock
DEFV(genere_Float,INIT(niveau_courant,loadF_point(imageA,X,Y)));
/* Valeur du point courant... */
Test(IFET(IFNE(niveau_courant,IFnivo_extrema_____niveau_minimum)
,IFNE(niveau_courant,IFnivo_extrema_____niveau_maximum)
)
)
Bblock
EGAL(IFnivo_extrema_____niveau_minimum_secondaire
,MIN2(IFnivo_extrema_____niveau_minimum_secondaire,niveau_courant)
);
EGAL(IFnivo_extrema_____niveau_maximum_secondaire
,MAX2(IFnivo_extrema_____niveau_maximum_secondaire,niveau_courant)
);
/* Recherche des extrema secondaires (introduites le 20091212204602), c'est-a-dire ceux */
/* qui sont les extrema en ayant supprime les extrema "reels" (dits "primaires"). Ceci fut */
/* introduit en particulier pour "etudier" les 'Z-Buffer's.... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_image
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M I N I M U M D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,IFnivo_minimum(imageA)))
DEFV(Argument,DEFV(imageF,imageA));
/* Image flottante argument. */
/* la valeur de la fonction est le minimum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une image flottante. */
DEFV(genere_Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une image flottante. */
/*..............................................................................................................................*/
CALS(IFnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_minimum);
/* Renvoi du minimum. */
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M A X I M U M D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,IFnivo_maximum(imageA)))
DEFV(Argument,DEFV(imageF,imageA));
/* Image flottante argument. */
/* la valeur de la fonction est le maximum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une image flottante. */
DEFV(genere_Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une image flottante. */
/*..............................................................................................................................*/
CALS(IFnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_maximum);
/* Renvoi du maximum. */
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S P A R T I E S R E E L L E E T I M A G I N A I R E */
/* D E S N I V E A U X D ' U N E I M A G E C O M P L E X E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(genere_Float,INIT(IJnivo_extrema_____niveau_minimum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IJnivo_extrema_____niveau_minimum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IJnivo_extrema_____niveau_maximum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(IJnivo_extrema_____niveau_maximum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
/* Diverses mesures lors de chaque passage dans 'IFnivo_extrema(...)' introduites le */
/* 20030930135517. */
DEFV(Common,DEFV(FonctionI,IJnivo_extrema(imageA,ARGUMENT_POINTEUR(nivo_minimum),ARGUMENT_POINTEUR(nivo_maximum))))
/* Cette fonction a ete introduite le 20030210173332 en vue de faire ensuite des */
/* verifications des nombres flottants ainsi recuperes dans 'IloadJ_image(...)' (voir */
/* 'v $xiii/files$FON IloadJ_image_____valider_les_genere_Float'). On n'oubliera pas a */
/* ce propos que les nombres flottants des 'SYSTEME_APC' ne sont pas compatibles, en */
/* general, avec les autres SYSTEMEs, d'ou cette possible verification... */
/* */
/* On notera de plus, qu'en l'absence de relation d'ordre dans les nombres complexes, ces */
/* extremas sont calcules a partir des parties Reelle et Imaginaire de chaque nombre */
/* complexe manipule... */
DEFV(Argument,DEFV(imageJ,imageA));
/* Image flottante Argument. */
DEFV(Argument,DEFV(Float,POINTEUR(nivo_minimum)));
/* Pointeur sur la valeur du minimum rencontre dans l'image flottante argument. */
DEFV(Argument,DEFV(Float,POINTEUR(nivo_maximum)));
/* Pointeur sur la valeur du maximum rencontre dans l'image flottante argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
BDEFV(imageF,partie_____reelle);
BDEFV(imageF,partie_imaginaire);
BDEFV(imageF,minimum_des_parties_reelle_et_imaginaire);
BDEFV(imageF,maximum_des_parties_reelle_et_imaginaire);
/* Parties Reelle et Imaginaire de 'imageA', ainsi leurs extrema "locaux"... */
/* */
/* Je note le 20061122165105 que 'partie_____reelle' s'appelle ainsi afin d'avoir la */
/* meme longueur que 'partie_imaginaire'... */
DEFV(genere_Float,INIT(nivo_minimum_temporaire,FLOT__NIVEAU_UNDEF));
DEFV(genere_Float,INIT(nivo_maximum_temporaire,FLOT__NIVEAU_UNDEF));
/* Destines uniquement a faire les appels a 'IFnivo_extrema(...)'... */
DEFV(Float,INIT(niveau_minimum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire,FLOT__NIVEAU_UNDEF));
DEFV(Float,INIT(niveau_maximum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire,FLOT__NIVEAU_UNDEF));
DEFV(Float,INIT(niveau_minimum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire,FLOT__NIVEAU_UNDEF));
DEFV(Float,INIT(niveau_maximum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire,FLOT__NIVEAU_UNDEF));
/* Extrema des extrema... */
/*..............................................................................................................................*/
CALS(Icomplexe_reelle(partie_____reelle,imageA));
CALS(Icomplexe_imaginaire(partie_imaginaire,imageA));
/* Extraction des parties Reelle et Imaginaire... */
CALS(IFminimum(minimum_des_parties_reelle_et_imaginaire,partie_____reelle,partie_imaginaire));
CALS(IFmaximum(maximum_des_parties_reelle_et_imaginaire,partie_____reelle,partie_imaginaire));
/* Calcul de leurs extrema "locaux"... */
/* */
/* ATTENTION, l'utilisation de 'IFminimum(...)' et de 'IFmaximum(...)' a demande a ce que */
/* 'image_image_TRI_IMAGE_EXT' soit deplace de 'v $xi/INCLUDES_all$I 20031002121556' vers */
/* 'v $xi/INCLUDES_bas$I 20031002121832'... */
CALS(IFnivo_extrema(minimum_des_parties_reelle_et_imaginaire
,ADRESSE(nivo_minimum_temporaire)
,ADRESSE(nivo_maximum_temporaire)
)
);
EGAL(IJnivo_extrema_____niveau_minimum
,IFnivo_extrema_____niveau_minimum
);
EGAL(niveau_minimum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire
,IFnivo_extrema_____niveau_minimum_en_valeur_absolue
);
EGAL(niveau_maximum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire
,IFnivo_extrema_____niveau_maximum_en_valeur_absolue
);
/* Recherche du minimum. */
CALS(IFnivo_extrema(maximum_des_parties_reelle_et_imaginaire
,ADRESSE(nivo_minimum_temporaire)
,ADRESSE(nivo_maximum_temporaire)
)
);
EGAL(IJnivo_extrema_____niveau_maximum
,IFnivo_extrema_____niveau_maximum
);
EGAL(niveau_minimum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire
,IFnivo_extrema_____niveau_minimum_en_valeur_absolue
);
EGAL(niveau_maximum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire
,IFnivo_extrema_____niveau_maximum_en_valeur_absolue
);
/* Recherche du maximum. */
EGAL(IJnivo_extrema_____niveau_minimum_en_valeur_absolue
,MIN2(niveau_minimum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire
,niveau_minimum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire
)
);
/* Determination du minimum en valeur absolue. */
EGAL(IJnivo_extrema_____niveau_maximum_en_valeur_absolue
,MAX2(niveau_maximum_en_valeur_absolue_des_minima_des_parties_reelle_et_imaginaire
,niveau_maximum_en_valeur_absolue_des_maxima_des_parties_reelle_et_imaginaire
)
);
/* Determination du maximum en valeur absolue. */
EGAL(INDIRECT(nivo_minimum),IJnivo_extrema_____niveau_minimum);
EGAL(INDIRECT(nivo_maximum),IJnivo_extrema_____niveau_maximum);
/* Renvoi des extrema principaux... */
EDEFV(imageF,maximum_des_parties_reelle_et_imaginaire);
EDEFV(imageF,minimum_des_parties_reelle_et_imaginaire);
EDEFV(imageF,partie_imaginaire);
EDEFV(imageF,partie_____reelle);
/* Parties Reelle et Imaginaire de 'imageA', ainsi leurs extrema "locaux"... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M I N I M U M D E S P A R T I E S R E E L L E E T I M A G I N A I R E */
/* D E S N I V E A U X D ' U N E I M A G E C O M P L E X E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,IJnivo_minimum(imageA)))
DEFV(Argument,DEFV(imageJ,imageA));
/* Image flottante argument. */
/* la valeur de la fonction est le minimum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une image flottante. */
DEFV(Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une image flottante. */
/*..............................................................................................................................*/
CALS(IJnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_minimum);
/* Renvoi du minimum. */
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M A X I M U M D E S P A R T I E S R E E L L E E T I M A G I N A I R E */
/* D E S N I V E A U X D ' U N E I M A G E C O M P L E X E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,IJnivo_maximum(imageA)))
DEFV(Argument,DEFV(imageJ,imageA));
/* Image flottante argument. */
/* la valeur de la fonction est le maximum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une image flottante. */
DEFV(Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une image flottante. */
/*..............................................................................................................................*/
CALS(IJnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_maximum);
/* Renvoi du maximum. */
Eblock
EFonctionF
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S N I V E A U X D ' U N E I M A G E D O U B L E P R E C I S I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_minimum,DPRE(NIVEAU_UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_minimum_en_valeur_absolue,DPRE(NIVEAU_UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____cumul_des_niveaux,DPRE(UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,DPRE(UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_moyen,DPRE(NIVEAU_UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_moyen_en_valeur_absolue,DPRE(NIVEAU_UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_maximum,DPRE(NIVEAU_UNDEF))));
DEFV(Common,DEFV(Double,INIT(IDnivo_extrema_____niveau_maximum_en_valeur_absolue,DPRE(NIVEAU_UNDEF))));
/* Diverses mesures lors de chaque passage dans 'IDnivo_extrema(...)'. */
/* */
/* Les '*imum_en_valeur_absolue_dans_IDnivo_extrema' ont ete introduits le 20030930144143. */
DEFV(Common,DEFV(FonctionI,IDnivo_extrema(imageA,ARGUMENT_POINTEUR(nivo_minimum),ARGUMENT_POINTEUR(nivo_maximum))))
DEFV(Argument,DEFV(imageD,imageA));
/* Image double precision Argument. */
DEFV(Argument,DEFV(Double,POINTEUR(nivo_minimum)));
/* Pointeur sur la valeur du minimum rencontre dans l'image double precision argument. */
DEFV(Argument,DEFV(Double,POINTEUR(nivo_maximum)));
/* Pointeur sur la valeur du maximum rencontre dans l'image double precision argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
EGAL(IDnivo_extrema_____niveau_minimum,D_INFINI);
EGAL(IDnivo_extrema_____niveau_minimum_en_valeur_absolue,D_INFINI);
/* Initialisation du minimum sur une forte valeur positive. */
EGAL(IDnivo_extrema_____niveau_maximum,D_MOINS_L_INFINI);
EGAL(IDnivo_extrema_____niveau_maximum_en_valeur_absolue,D_MOINS_L_INFINI);
/* Initialisation du maximum sur une forte valeur negative. */
EGAL(IDnivo_extrema_____cumul_des_niveaux,FZERO);
EGAL(IDnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FZERO);
/* Initialisation du cumul des niveaux rencontres... */
begin_image
Bblock
DEFV(Double,INIT(niveau_courant,loadD_point(imageA,X,Y)));
DEFV(Double,INIT(niveau_courant_en_valeur_absolue,DPRE(NIVEAU_UNDEF)));
/* Valeur du point courant et sa valeur absolue... */
EGAL(niveau_courant_en_valeur_absolue,ABSO(niveau_courant));
/* Valeur absolue du niveau courant en {X,Y}. */
INCR(IDnivo_extrema_____cumul_des_niveaux,niveau_courant);
INCR(IDnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,niveau_courant_en_valeur_absolue);
/* Cumul des niveaux... */
EGAL(IDnivo_extrema_____niveau_minimum
,MIN2(IDnivo_extrema_____niveau_minimum,niveau_courant)
);
EGAL(IDnivo_extrema_____niveau_minimum_en_valeur_absolue
,MIN2(IDnivo_extrema_____niveau_minimum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
EGAL(IDnivo_extrema_____niveau_maximum
,MAX2(IDnivo_extrema_____niveau_maximum,niveau_courant)
);
EGAL(IDnivo_extrema_____niveau_maximum_en_valeur_absolue
,MAX2(IDnivo_extrema_____niveau_maximum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
Eblock
end_image
EGAL(IDnivo_extrema_____niveau_moyen
,DIVI(IDnivo_extrema_____cumul_des_niveaux,DPRE(dimXY))
);
EGAL(IDnivo_extrema_____niveau_moyen_en_valeur_absolue
,DIVI(IDnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,DPRE(dimXY))
);
EGAL(INDIRECT(nivo_minimum),IDnivo_extrema_____niveau_minimum);
EGAL(INDIRECT(nivo_maximum),IDnivo_extrema_____niveau_maximum);
/* Diverses mesures... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M I N I M U M D E S N I V E A U X D ' U N E I M A G E D O U B L E P R E C I S I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,IDnivo_minimum(imageA)))
DEFV(Argument,DEFV(imageD,imageA));
/* Image double precision argument. */
/* la valeur de la fonction est le minimum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Double,INIT(nivo_minimum,DPRE(UNDEF)));
/* Minimum des niveaux d'une image double precision. */
DEFV(Double,INIT(nivo_maximum,DPRE(UNDEF)));
/* Maximum des niveaux d'une image double precision. */
/*..............................................................................................................................*/
CALS(IDnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_minimum);
/* Renvoi du minimum. */
Eblock
EFonctionD
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M A X I M U M D E S N I V E A U X D ' U N E I M A G E D O U B L E P R E C I S I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionD
DEFV(Common,DEFV(FonctionD,IDnivo_maximum(imageA)))
DEFV(Argument,DEFV(imageD,imageA));
/* Image double precision argument. */
/* la valeur de la fonction est le maximum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Double,INIT(nivo_minimum,DPRE(UNDEF)));
/* Minimum des niveaux d'une image double precision. */
DEFV(Double,INIT(nivo_maximum,DPRE(UNDEF)));
/* Maximum des niveaux d'une image double precision. */
/*..............................................................................................................................*/
CALS(IDnivo_extrema(imageA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_maximum);
/* Renvoi du maximum. */
Eblock
EFonctionD
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E S E X T R E M A D E S N I V E A U X D ' U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_minimum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_minimum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(Float,INIT(AFnivo_extrema_____cumul_des_niveaux,FLOT__UNDEF)));
DEFV(Common,DEFV(Float,INIT(AFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FLOT__UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_moyen,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_moyen_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_maximum,FLOT__NIVEAU_UNDEF)));
DEFV(Common,DEFV(genere_Float,INIT(AFnivo_extrema_____niveau_maximum_en_valeur_absolue,FLOT__NIVEAU_UNDEF)));
/* Diverses mesures lors de chaque passage dans 'AFnivo_extrema(...)'. */
/* */
/* Les '*imum_en_valeur_absolue_dans_AFnivo_extrema' ont ete introduits le 20030930144143. */
DEFV(Common,DEFV(FonctionI,AFnivo_extrema(albumA,ARGUMENT_POINTEUR(nivo_minimum),ARGUMENT_POINTEUR(nivo_maximum))))
DEFV(Argument,DEFV(albumF,albumA));
/* Album flottant Argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_minimum)));
/* Pointeur sur la valeur du minimum rencontre dans l'album flottant argument. */
DEFV(Argument,DEFV(genere_Float,POINTEUR(nivo_maximum)));
/* Pointeur sur la valeur du maximum rencontre dans l'album flottant argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
EGAL(AFnivo_extrema_____niveau_minimum,F_INFINI);
EGAL(AFnivo_extrema_____niveau_minimum_en_valeur_absolue,F_INFINI);
/* Initialisation du minimum sur une forte valeur positive. */
EGAL(AFnivo_extrema_____niveau_maximum,F_MOINS_L_INFINI);
EGAL(AFnivo_extrema_____niveau_maximum_en_valeur_absolue,F_MOINS_L_INFINI);
/* Initialisation du maximum sur une forte valeur negative. */
EGAL(AFnivo_extrema_____cumul_des_niveaux,FZERO);
EGAL(AFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FZERO);
/* Initialisation du cumul des niveaux rencontres... */
begin_album
Bblock
DEFV(genere_Float,INIT(niveau_courant,AloadF_point(albumA,X,Y,Z)));
DEFV(genere_Float,INIT(niveau_courant_en_valeur_absolue,FLOT__NIVEAU_UNDEF));
/* Valeur du point courant et sa valeur absolue... */
EGAL(niveau_courant_en_valeur_absolue,ABSO(niveau_courant));
/* Valeur absolue du niveau courant en {X,Y}. */
INCR(AFnivo_extrema_____cumul_des_niveaux,niveau_courant);
INCR(AFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,niveau_courant_en_valeur_absolue);
/* Cumul des niveaux... */
EGAL(AFnivo_extrema_____niveau_minimum
,MIN2(AFnivo_extrema_____niveau_minimum,niveau_courant)
);
EGAL(AFnivo_extrema_____niveau_minimum_en_valeur_absolue
,MIN2(AFnivo_extrema_____niveau_minimum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
EGAL(AFnivo_extrema_____niveau_maximum
,MAX2(AFnivo_extrema_____niveau_maximum,niveau_courant)
);
EGAL(AFnivo_extrema_____niveau_maximum_en_valeur_absolue
,MAX2(AFnivo_extrema_____niveau_maximum_en_valeur_absolue,niveau_courant_en_valeur_absolue)
);
Eblock
end_album
EGAL(AFnivo_extrema_____niveau_moyen
,DIVI(AFnivo_extrema_____cumul_des_niveaux,FLOT(dimXYZ))
);
EGAL(AFnivo_extrema_____niveau_moyen_en_valeur_absolue
,DIVI(AFnivo_extrema_____cumul_des_niveaux_en_valeur_absolue,FLOT(dimXYZ))
);
EGAL(INDIRECT(nivo_minimum),AFnivo_extrema_____niveau_minimum);
EGAL(INDIRECT(nivo_maximum),AFnivo_extrema_____niveau_maximum);
/* Diverses mesures... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M I N I M U M D E S N I V E A U X D ' U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,AFnivo_minimum(albumA)))
DEFV(Argument,DEFV(albumF,albumA));
/* Album flottant argument. */
/* la valeur de la fonction est le minimum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une album flottant. */
DEFV(genere_Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une album flottant. */
/*..............................................................................................................................*/
CALS(AFnivo_extrema(albumA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_minimum);
/* Renvoi du minimum. */
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U M A X I M U M D E S N I V E A U X D ' U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(FonctionF,AFnivo_maximum(albumA)))
DEFV(Argument,DEFV(albumF,albumA));
/* Album flottant argument. */
/* la valeur de la fonction est le maximum recherche. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(genere_Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF));
/* Minimum des niveaux d'une album flottant. */
DEFV(genere_Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF));
/* Maximum des niveaux d'une album flottant. */
/*..............................................................................................................................*/
CALS(AFnivo_extrema(albumA,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum)));
/* Recherche des extrema. */
RETU(nivo_maximum);
/* Renvoi du maximum. */
Eblock
EFonctionF
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V E R I F I C A T I O N D E L A " Q U A L I T E " */
/* D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionL
DEFV(Common,DEFV(FonctionL,IFau_moins_un_niveau_est_incorrect(imageA,editer_les_anomalies)))
/* Le 20030213092031, cette fonction a ete refencee dans 'IloadF_image(...)' (voir */
/* 'v $xiii/files$FON IloadF_image_____valider_les_genere_Float'). On n'oubliera pas a */
/* ce propos que les nombres flottants des 'SYSTEME_APC' ne sont pas compatibles, en */
/* general, avec les autres SYSTEMEs, d'ou cette possible verification... */
DEFV(Argument,DEFV(imageF,imageA));
/* Image flottante Argument. */
DEFV(Argument,DEFV(Logical,editer_les_anomalies));
/* Faut-il editer la localisation et le type d'anomalie (introduit le 20030301093054). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(il_y_a_au_moins_un_niveau_incorrect,FAUX));
/* Futur valeur de retour... */
/*..............................................................................................................................*/
begin_image
Bblock
DEFV(genere_Float,INIT(niveau_courant,loadF_point(imageA,X,Y)));
/* Recuperation du niveau courant en {X,Y}. */
Test(EST_UN_BON_Float_FINI(niveau_courant))
Bblock
Eblock
ATes
Bblock
Test(IL_FAUT(editer_les_anomalies))
Bblock
PRINT_ERREUR("une image contient au moins un point flottant incorrect");
CAL1(Prer3("ses coordonnees sont {%d,%d} et sa valeur est egale a {%g}\n",X,Y,niveau_courant));
Eblock
ATes
Bblock
Eblock
ETes
EGAL(il_y_a_au_moins_un_niveau_incorrect,VRAI);
/* Il y a au moins une valeur incorrecte... */
Eblock
ETes
Eblock
end_image
RETU(il_y_a_au_moins_un_niveau_incorrect);
Eblock
EFonctionL
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V E R I F I C A T I O N D E L A " Q U A L I T E " D E S P A R T I E S R E E L L E E T I M A G I N A I R E */
/* D E S N I V E A U X D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionL
DEFV(Common,DEFV(FonctionL,IJau_moins_un_niveau_est_incorrect(imageA,editer_les_anomalies)))
/* Cette fonction a ete introduite le 20030213092031 en vue de faire ensuite des */
/* verifications des nombres flottants ainsi recuperes dans 'IloadJ_image(...)' (voir */
/* 'v $xiii/files$FON IloadJ_image_____valider_les_genere_Float'). On n'oubliera pas a */
/* ce propos que les nombres flottants des 'SYSTEME_APC' ne sont pas compatibles, en */
/* general, avec les autres SYSTEMEs, d'ou cette possible verification... */
/* */
/* On notera de plus, qu'en l'absence de relation d'ordre dans les nombres complexes, ces */
/* extremas sont calcules a partir des parties Reelle et Imaginaire de chaque nombre */
/* complexe manipule... */
DEFV(Argument,DEFV(imageJ,imageA));
/* Image flottante Argument. */
DEFV(Argument,DEFV(Logical,editer_les_anomalies));
/* Faut-il editer la localisation et le type d'anomalie (introduit le 20030301093054). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(il_y_a_au_moins_un_niveau_incorrect,FAUX));
/* Futur valeur de retour... */
/*..............................................................................................................................*/
begin_image
Bblock
DEFV(genere_complexe,niveau_courant);
DEFV(Float,INIT(partie_____reelle,FLOT__NIVEAU_UNDEF));
DEFV(Float,INIT(partie_imaginaire,FLOT__NIVEAU_UNDEF));
/* Variables de manoeuvre (valeur du point courant). */
EGAL(niveau_courant,loadJ_point(imageA,X,Y));
EGAL(partie_____reelle,Reelle(niveau_courant));
EGAL(partie_imaginaire,Imaginaire(niveau_courant));
/* Recuperation du niveau courant en {X,Y}. */
Test(IFET(EST_UN_BON_Float_FINI(partie_____reelle),EST_UN_BON_Float_FINI(partie_imaginaire)))
Bblock
Eblock
ATes
Bblock
Test(IL_FAUT(editer_les_anomalies))
Bblock
PRINT_ERREUR("une image contient au moins un point complexe incorrect");
CAL1(Prer4("ses coordonnees sont {%d,%d} et sa valeur est egale a {%g,%g}\n"
,X,Y
,partie_____reelle,partie_imaginaire
)
);
Eblock
ATes
Bblock
Eblock
ETes
EGAL(il_y_a_au_moins_un_niveau_incorrect,VRAI);
/* Il y a au moins une valeur incorrecte... */
Eblock
ETes
Eblock
end_image
RETU(il_y_a_au_moins_un_niveau_incorrect);
Eblock
EFonctionL
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E G R A N D E U R S S T A T I S T I Q U E S S U R U N E I M A G E M A S Q U E E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(Ihistogramme_____compatibilite_20081005,FAUX)));
/* Permet de generer des histogrammes suivant la methode anterieure au 20081005122026... */
DEFV(Common,DEFV(FonctionI,Ihistogramme(imageA)))
DEFV(Argument,DEFV(image,imageA));
/* Image Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(genere_p,INIT(niveau_courant,NIVEAU_UNDEF));
/* Variable de manoeuvre (valeur du point courant). */
DEFV(Float,INIT(cumul_niveau,FLOT__UNDEF));
/* Pour calculer le niveau moyen. */
DEFV(Positive,INIT(cumul_points,UNDEF));
/* Pour valider l'histogramme. */
/*..............................................................................................................................*/
CLIR(Ihistogramme______nombre_de_points);
/* Initialisation du calcul du nombre de points dans l'image. */
CLIR(cumul_niveau);
/* Initialisation du calcul du niveau moyen. */
EGAL(Ihistogramme______niveau_minimal,BLANC);
/* Initialisation du minimum sur la plus forte valeur possible : */
/* */
/* ATTENTION, il y a eu pendant longtemps : */
/* */
/* EGAL(Ihistogramme______niveau_minimal,INFINI); */
/* */
/* mais cette valeur 'INFINI' n'est pas possible pour un 'genere_p'... */
EGAL(Ihistogramme______niveau_maximal,NOIR);
/* Initialisation du maximum sur la plus faible valeur possible : */
/* */
/* ATTENTION, il y a eu pendant longtemps : */
/* */
/* EGAL(Ihistogramme______niveau_maximal,MOINS_L_INFINI); */
/* */
/* mais cette valeur 'MOINS_L_INFINI' n'est pas possible pour un 'genere_p'... */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
CLIR(ACCES_HISTOGRAMME(niveau));
/* Initialisation du comptage dans l'histogramme. */
Eblock
EBoI
traite_image_BH_GD(BLOC(INCR(Ihistogramme______nombre_de_points,I);
/* Et on compte le nombre de points traites. */
EGAL(niveau_courant,load_point(imageA,X,Y));
INCR(cumul_niveau,FLOT(niveau_courant));
/* Pour calculer ulterieurement le niveau moyen. */
EGAL(Ihistogramme______niveau_minimal,MIN2(Ihistogramme______niveau_minimal,niveau_courant));
EGAL(Ihistogramme______niveau_maximal,MAX2(Ihistogramme______niveau_maximal,niveau_courant));
/* Recherche des extrema. */
INCR(ACCES_HISTOGRAMME(niveau_courant),I);
/* Mise a jour de l'histogramme par comptage du niveau courant 'niveau_courant'. */
)
);
Test(IZNE(Ihistogramme______nombre_de_points))
Bblock
EGAL(Ihistogramme______niveau_moyen,GENP(DIVI(cumul_niveau,FLOT(Ihistogramme______nombre_de_points))));
/* Lorsqu'au moins un point a ete traite, on peut calculer le niveau moyen... */
Eblock
ATes
Bblock
EGAL(Ihistogramme______niveau_moyen,NIVEAU_UNDEF);
/* Sinon, le niveau moyen est considere comme indefini. */
Eblock
ETes
CLIR(cumul_points);
/* Pour valider l'histogramme. */
EGAL(Ihistogramme______nombre_de_points_minimal,INFINI);
/* Initialisation du minimum sur une forte valeur positive. */
EGAL(Ihistogramme______nombre_de_points_maximal,MOINS_L_INFINI);
/* Initialisation du maximum sur une forte valeur negative. */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
INCR(cumul_points,ACCES_HISTOGRAMME(niveau));
EGAL(Ihistogramme______nombre_de_points_minimal,MIN2(Ihistogramme______nombre_de_points_minimal,ACCES_HISTOGRAMME(niveau)));
EGAL(Ihistogramme______nombre_de_points_maximal,MAX2(Ihistogramme______nombre_de_points_maximal,ACCES_HISTOGRAMME(niveau)));
/* Et enfin, recherche du plus petit et du plus grand nombres de points */
/* possedant un meme niveau. */
Eblock
EBoI
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
Test(IFEQ(niveau,NOIR))
Bblock
EGAL(ACCES_HISTOGRAMME_CUMULE(niveau)
,ACCES_HISTOGRAMME(niveau)
);
/* Pour le niveau 'NOIR' il y a identite entre l'histogramme et l'histogramme "cumule"... */
Eblock
ATes
Bblock
EGAL(ACCES_HISTOGRAMME_CUMULE(niveau)
,ADD2(ACCES_HISTOGRAMME_CUMULE(PREN(niveau)),ACCES_HISTOGRAMME(niveau))
);
/* Au-dela, on cumule avec les niveaux anterieurs... */
Eblock
ETes
Eblock
EBoI
Test(IFEQ(cumul_points,Ihistogramme______nombre_de_points))
Bblock
DEFV(Int,INIT(borne_superieure_du_niveau,UNDEF));
/* Index de determination du classement des niveaux (mis ici le 20081006135953...). */
DEFV(Int,DTb1(histogramme_de_manoeuvre,COULEURS));
/* Copie de l'histogramme destinee a calculer le classement des niveaux (mis ici le */
/* 20081006135953...). */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
EGAL(ITb1(histogramme_de_manoeuvre,INDX(niveau,NOIR)),ACCES_HISTOGRAMME(niveau));
/* Initialisation de l'histogramme de manoeuvre destine a classer les niveaux. */
EGAL(ITb1(classement_des_niveaux,INDX(niveau,NOIR)),niveau);
/* Initialisation a priori du classement des niveaux. */
Eblock
EBoI
BoDe(borne_superieure_du_niveau,NOIR,PREN(BLANC),PAS_COULEURS)
Bblock
BoIn(niveau,NOIR,borne_superieure_du_niveau,PAS_COULEURS)
Bblock
Test(IFOU(IFET(IL_NE_FAUT_PAS(Ihistogramme_____compatibilite_20081005)
,IFGT(ITb1(histogramme_de_manoeuvre,INDX(NEUT(niveau),NOIR))
,ITb1(histogramme_de_manoeuvre,INDX(SUCN(niveau),NOIR))
)
)
,IFET(IL_FAUT(Ihistogramme_____compatibilite_20081005)
,IFLT(ITb1(histogramme_de_manoeuvre,INDX(NEUT(niveau),NOIR))
,ITb1(histogramme_de_manoeuvre,INDX(SUCN(niveau),NOIR))
)
)
)
)
/* Le 20081005115416, j'ai remplace 'IFLT(...)' par 'IFGT(...)' puisqu'il va donner un */
/* classement croissant et non pas decroissant : les premiers niveaux seront les moins */
/* peuples, alors que les derniers niveaux seront les plus peuples, ce qui est beaucoup */
/* plus logique... */
Bblock
SWAP(ITb1(histogramme_de_manoeuvre,INDX(NEUT(niveau),NOIR))
,ITb1(histogramme_de_manoeuvre,INDX(SUCN(niveau),NOIR))
);
SWAP(ITb1(classement_des_niveaux,INDX(NEUT(niveau),NOIR))
,ITb1(classement_des_niveaux,INDX(SUCN(niveau),NOIR))
);
/* Le 20081004114822, je note que 'TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE(...)' */
/* pourrait etre utilise ici. En fait, je n'opere pas cette modification car, en effet, */
/* demanderait de parametrer {BoDe,BoIn,EBoI,EBoD}, ainsi que {PREN,SUCN} et 'SWAP'... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EBoI
Eblock
EBoD
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
MODIFICATION_LISTE_DE_SUBSTITUTION_HISTOGRAMME(niveau,ITb1(classement_des_niveaux,INDX(niveau,NOIR)));
/* Mise en place de la liste de SUBSTITUTION "histogramme" (introduite le 20081004120006). */
Eblock
EBoI
EGAL(Ihistogramme_____etat,VALIDE);
/* Et on memorise que les donnees sont valides. Ceci fut mis tout a la fin le 20081006135233 */
/* alors qu'avant cette date c'etait juste apres le 'Test(...)' associe au 'ATes' qui suit. */
Eblock
ATes
Bblock
PRINT_ERREUR("l'histogramme est incoherent");
EGAL(Ihistogramme_____etat,INVALIDE);
/* Et on invalide l'histogramme... */
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 */
/* D E " H A U S D O R F F " G E N E R A L I S E E D ' U N E I M A G E : */
/* */
/* */
/* Definition : */
/* */
/* On va considerer le 'Masque' courant, */
/* et pour toutes les valeurs du seuil de */
/* masquage 'S' dans [NOIR,BLANC] on va calculer */
/* l'histogramme de l'image Argument. On en */
/* extrait le nombre 'N' de points possedant */
/* un niveau argument 'C' donne. Ainsi, 'S' */
/* definit en quelque sorte une "boite" */
/* generalisee (dont la forme non necessairement */
/* connexe est donnee par l'image Masque) et a */
/* l'interieur de laquelle on calcule le nombre */
/* 'N' de points possedant le niveau Argument */
/* 'C' ; on dira par generalisation que 'S' est */
/* la taille de la boite. Ainsi, on definira la */
/* dimension generalisee de Hausdorff 'H' par */
/* rapport au niveau Argument 'C' comme etant */
/* le rapport : */
/* */
/* log(N) */
/* H(C) = ----------, moyenne sur toutes les valeurs de 'S' dans [NOIR,BLANC], */
/* 1 */
/* log(e + S) */
/* 1 */
/* 'S' etant en fait translate a l'aide de e afin */
/* d'eviter des divisions par 0... */
/* */
/* */
/* ATTENTION : */
/* */
/* Je note le 20100525093939 (tres tardivement...) */
/* que pour un seuil donne 'S', on ne mesure le nombre */
/* 'N' de points de numero 'C' que dans une seule boite */
/* (definie par le 'Masque' courant) et que cette boite, */
/* ne se deplace donc pas sur 'imageA' pour faire de */
/* nombreuses mesures (une seule est donc faite pour un */
/* seuil donne 'S' ! Cela signifie au passage que pour */
/* les plus petites boites il se peut qu'il n'y ait */
/* aucun point dedans...). */
/* */
/*************************************************************************************************************************************/
BFonctionF
#define TAILLE_DES_BOITES(niveau) \
LOGX(ADD2(EXPB(UNITE),FLOT(VCOMP(niveau)))) \
/* Pour passer d'un niveau au logarithme de la taille d'une boite tel qu'il */ \
/* ne puisse etre nul afin de figurer en denominateur de fractions ; */ \
/* le 'VCOMP' est utilise ici, car en effet, plus 'niveau' est petit */ \
/* (c'est-a-dire proche de 'NOIR'), plus la boite est physiquement grande */ \
/* (plus elle a de points). */ \
/* */ \
/* On notera que l'on utilise 'EXPB(...)' et non pas 'EXPX(...)' a cause du bug */ \
/* 'BUG_SYSTEME_SG_C_exp'... */
DEFV(Common,DEFV(FonctionF,IFdimension_fractale(imageA
,niveau_de_calcul_de_la_dimension
,niveau_de_depart,niveau_d_arrivee
,pas_des_niveaux
)
)
)
/* ATTENTION : pour calculer la dimension fractale par rapport a un niveau */
/* de gris argument on va utiliser une suite de "boites" de taille decroissante ; */
/* ces boites sont en fait donnees par l'image "Masque" (ce sera par exemple une */
/* 'spirale carree'), et la decroissance des tailles se fait en faisant varier */
/* le niveau de masquage de 'NOIR' a 'BLANC'... */
DEFV(Argument,DEFV(image,imageA));
/* Image Argument (ne pas oublier donc que 'Masque' est aussi un Argument, */
/* puisque c'est lui qui donne la forme des "boites"...). */
DEFV(Argument,DEFV(genere_p,niveau_de_calcul_de_la_dimension));
/* Niveau pour lequel on calcule la dimension fractale. */
DEFV(Argument,DEFV(genere_p,niveau_de_depart));
/* Niveau de la premiere boite du calcul (en general 'NOIR'), */
DEFV(Argument,DEFV(genere_p,niveau_d_arrivee));
/* Niveau de la derniere boite du calcul (en general 'BLANC'). */
DEFV(Argument,DEFV(Int,pas_des_niveaux));
/* Pas de passage du niveau de depart au niveau d'arrivee (en general */
/* 'PAS_COULEURS'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(taille_des_boites,UNDEF));
/* Pour fixer, via le niveau de masquage, la taille decroissante des "boites". */
DEFV(Int,DTb1(population_des_boites,COULEURS));
/* Pour chaque taille (ou niveau de masquage) on trouve la population (c'est-a-dire */
/* le nombre de points contenus) de la "boite" correspondante. */
DEFV(Int,INIT(nombre_de_niveaux_cumules,ZERO));
/* On ne comptera que les niveaux ou l'on a trouve des points... */
DEFV(Float,INIT(cumul_de_la_dimension_fractale,FZERO));
/* La dimension fractale Resultat va etre calculee par une moyenne sur l'ensemble */
/* des boites ; elle est initialisee a zero... */
/*..............................................................................................................................*/
Test(IFOU(IZLE(TAILLE_DES_BOITES(NOIR))
,IZLE(TAILLE_DES_BOITES(BLANC))
)
)
Bblock
PRINT_ERREUR("lors du calcul de la dimension fractale, il va y avoir une division par 0");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IZLE(TAILLE_DES_BOITES(niveau_de_depart))
,IZLE(TAILLE_DES_BOITES(niveau_d_arrivee))
)
)
Bblock
PRINT_ERREUR("lors du calcul de la dimension fractale, il va y avoir une division par 0");
Eblock
ATes
Bblock
Eblock
ETes
PUSH_MASQUE;
/* Sauvegarde de l'etat de masquage initial. */
DoIn(taille_des_boites,niveau_de_depart,niveau_d_arrivee,pas_des_niveaux)
Bblock
MASQUE_IMAGES(taille_des_boites);
/* Ainsi on va faire diminuer la taille des "boites" en masquant du 'NOIR' (ou */
/* finalement tous les points de l'image seront pris : la taille de la "boite" */
/* est alors celle d'une image entiere) a 'BLANC' (ou aucun ne sera pris : la */
/* taille de la "boite" est alors nulle). */
CALS(Ihistogramme(imageA));
/* Calcul de l'histogramme de l'image Argument suivant le 'Masque' courant. */
EGAL(ITb1(population_des_boites,INDX(taille_des_boites,NOIR))
,ACCES_HISTOGRAMME(niveau_de_calcul_de_la_dimension)
);
/* La population de la "boite" courante (donnee par le 'Masque') est egale */
/* a l'histogramme du niveau pour lequel on calcule la dimension fractale. */
Test(IZLT(ITb1(population_des_boites,INDX(taille_des_boites,NOIR))))
Bblock
PRINT_ERREUR("une valeur negative est trouvee dans l'histogramme");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
DoIn(taille_des_boites,niveau_de_depart,niveau_d_arrivee,pas_des_niveaux)
Bblock
Test(IZGT(ITb1(population_des_boites,INDX(taille_des_boites,NOIR))))
Bblock
INCR(nombre_de_niveaux_cumules,I);
/* Comptage des niveaux pour lesquels on a trouve des points. */
INCR(cumul_de_la_dimension_fractale
,DIVI(LOGX(ITb1(population_des_boites,INDX(taille_des_boites,NOIR)))
,TAILLE_DES_BOITES(taille_des_boites)
)
);
/* Le 'VCOMP' est utilise ici (dans 'TAILLE_DES_BOITES'), car en effet, plus */
/* 'taille_des_boites' est petit (c'est-a-dire proche de 'NOIR'), plus la */
/* boite est physiquement grande (plus elle a de points) ; le 'TAILLE_DES_BOITES' */
/* est la pour eviter d'une part de prendre le logarithme de 0 et d'autre part */
/* pour ne pas tomber sur un logarithme qui soit nul, et donc ne pas diviser */
/* par 0... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
PULL_MASQUE;
/* Restauration de l'etat de masquage initial... */
RETU(COND(IZGT(nombre_de_niveaux_cumules)
,DIVI(cumul_de_la_dimension_fractale,FLOT(nombre_de_niveaux_cumules))
,DIMENSION_FRACTALE_NULLE
)
);
/* Et renvoi de la dimension fractale moyenne... */
Eblock
#undef TAILLE_DES_BOITES
EFonctionF
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L M A S Q U E D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N E I M A G E S T A N D A R D : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Icomptage_des_points_dans_un_intervalle(imageA1,niveau_origine,niveau_extremite)))
DEFV(Argument,DEFV(image,imageA1));
/* Image Argument, */
DEFV(Argument,DEFV(genere_p,niveau_origine));
DEFV(Argument,DEFV(genere_p,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
traite_image_BH_GD(BLOC(Test(IFINff(load_point(imageA1,X,Y),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
)
);
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'image Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L M A S Q U E D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IFcomptage_des_points_dans_un_intervalle(imageA1,niveau_origine,niveau_extremite)))
DEFV(Argument,DEFV(imageF,imageA1));
/* Image Argument, */
DEFV(Argument,DEFV(genere_Float,niveau_origine));
DEFV(Argument,DEFV(genere_Float,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
traite_image_BH_GD(BLOC(Test(IFINff(loadF_point(imageA1,X,Y),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
)
);
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'image Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N D O M A I N E R E C T A N G U L A I R E D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IFdomaine_comptage_des_points_dans_un_intervalle(imageA1
,domaine_Xmin,domaine_Xmax
,domaine_Ymin,domaine_Ymax
,niveau_origine
,niveau_extremite
)
)
)
DEFV(Argument,DEFV(imageF,imageA1));
/* Image Argument, */
DEFV(Argument,DEFV(Int,domaine_Xmin));
DEFV(Argument,DEFV(Int,domaine_Xmax));
DEFV(Argument,DEFV(Int,domaine_Ymin));
DEFV(Argument,DEFV(Int,domaine_Ymax));
/* Definition du domaine rectangulaire... */
DEFV(Argument,DEFV(genere_Float,niveau_origine));
DEFV(Argument,DEFV(genere_Float,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
begin_imageQ(DoIn,MAX2(Ymin,domaine_Ymin),MIN2(Ymax,domaine_Ymax),PasY
,DoIn,MAX2(Xmin,domaine_Xmin),MIN2(Xmax,domaine_Xmax),PasX
)
Bblock
Test(IFINff(loadF_point(imageA1,X,Y),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_imageQ(EDoI,EDoI)
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'image Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L M A S Q U E D U N O M B R E D E C O I N C I D E N C E S */
/* E N T R E D E U X I M A G E S S T A N D A R D : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Icomptage_des_coincidences(imageA1,imageA2)))
DEFV(Argument,DEFV(image,imageA1));
/* Premiere image Argument, */
DEFV(Argument,DEFV(image,imageA2));
/* Deuxieme image Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_coincidences,ZERO));
/* Nombre de coincidences entre les deux images arguments (initialement, aucune). */
/*..............................................................................................................................*/
traite_image_BH_GD(BLOC(Test(IFEQ(load_point(imageA1,X,Y),load_point(imageA2,X,Y)))
Bblock
INCR(nombre_de_coincidences,I);
/* Comptage des coincidences entre les deux images arguments. */
Eblock
ATes
Bblock
Eblock
ETes
)
);
RETU(nombre_de_coincidences);
/* Et renvoi du nombre de coincidences entre les deux images arguments. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L M A S Q U E D U N O M B R E D E C O I N C I D E N C E S */
/* E N T R E D E U X I M A G E S F L O T T A N T E S : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IFcomptage_des_coincidences(imageA1,imageA2)))
DEFV(Argument,DEFV(imageF,imageA1));
/* Premiere image Argument, */
DEFV(Argument,DEFV(imageF,imageA2));
/* Deuxieme image Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_coincidences,ZERO));
/* Nombre de coincidences entre les deux images arguments (initialement, aucune). */
/*..............................................................................................................................*/
traite_image_BH_GD(BLOC(Test(IFEQ(loadF_point(imageA1,X,Y),loadF_point(imageA2,X,Y)))
Bblock
INCR(nombre_de_coincidences,I);
/* Comptage des coincidences entre les deux images arguments. */
Eblock
ATes
Bblock
Eblock
ETes
)
);
RETU(nombre_de_coincidences);
/* Et renvoi du nombre de coincidences entre les deux images arguments. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L G E N E R A L D U C E N T R E D E G R A V I T E : */
/* */
/*************************************************************************************************************************************/
#define CALCUL_D_UN_CENTRE_DE_GRAVITE(image,acces_image,type_image,seuil,centre_de_gravite_X,centre_de_gravite_Y) \
Bblock \
DEFV(Positive,INIT(nombre_de_points,ZERO)); \
DEFV(Float,INIT(cumul_des_niveaux,FZERO)); \
DEFV(Float,INIT(cumul_coordonnees_X_ponderees,FZERO)); \
DEFV(Float,INIT(cumul_coordonnees_Y_ponderees,FZERO)); \
\
traite_image_BH_GD(BLOC(DEFV(type_image,INIT(niveau_courant,acces_image(image,X,Y))); \
\
Test(IFGE(niveau_courant,seuil)) \
Bblock \
INCR(nombre_de_points,I); \
/* Ne sert a rien, mais on ne sait jamais... */ \
INCR(cumul_des_niveaux,niveau_courant); \
\
INCR(cumul_coordonnees_X_ponderees,MUL2(niveau_courant,_____cNORMALISE_OX(X))); \
INCR(cumul_coordonnees_Y_ponderees,MUL2(niveau_courant,_____cNORMALISE_OY(Y))); \
/* Seuls les points de niveau superieur [ou egal] au seuil sont pris en compte... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
\
Test(IZNE(cumul_des_niveaux)) \
/* Test manquant introduit le 20220205080727... */ \
Bblock \
EGAL(centre_de_gravite_X,DIVI(cumul_coordonnees_X_ponderees,cumul_des_niveaux)); \
EGAL(centre_de_gravite_Y,DIVI(cumul_coordonnees_Y_ponderees,cumul_des_niveaux)); \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("lors du calcul du centre de gravite, le cumul des niveaux est nul."); \
\
EGAL(centre_de_gravite_X,_____cNORMALISE_OX(Xcentre)); \
EGAL(centre_de_gravite_Y,_____cNORMALISE_OY(Ycentre)); \
/* Dans ces conditions, arbitrairement, on place le centre de gravite au centre... */ \
/* */ \
/* Cela peut se produire pour une image ne contenant que des zeros, mais aussi pour une */ \
/* image 'Float' ou les niveaux negatifs compensent les niveaux positifs... */ \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U C E N T R E D E G R A V I T E D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(genere_p,SINT(Icentre_de_gravite_____seuil,NOIR)));
DEFV(Common,DEFV(Float,SINT(Icentre_de_gravite_____ponderation_GX,FZERO)));
DEFV(Common,DEFV(Float,SINT(Icentre_de_gravite_____ponderation_GY,FZERO)));
DEFV(Common,DEFV(Float,INIT(Icentre_de_gravite_____coordonnee_X,FLOT__UNDEF)));
DEFV(Common,DEFV(Float,INIT(Icentre_de_gravite_____coordonnee_Y,FLOT__UNDEF)));
DEFV(Common,DEFV(FonctionF,Icentre_de_gravite(imageA)))
/* Fonction introduite le 20220204173407... */
DEFV(Argument,DEFV(image,imageA));
/* Image Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
/*..............................................................................................................................*/
CALCUL_D_UN_CENTRE_DE_GRAVITE(imageA
,load_point
,genere_p
,Icentre_de_gravite_____seuil
,Icentre_de_gravite_____coordonnee_X
,Icentre_de_gravite_____coordonnee_Y
);
RETU(LIZ2(Icentre_de_gravite_____ponderation_GX,Icentre_de_gravite_____coordonnee_X
,Icentre_de_gravite_____ponderation_GY,Icentre_de_gravite_____coordonnee_Y
)
);
Eblock
EFonctionF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U C E N T R E D E G R A V I T E D ' U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
BFonctionF
DEFV(Common,DEFV(genere_Float,SINT(IFcentre_de_gravite_____seuil,FLOT__NOIR)));
DEFV(Common,DEFV(Float,SINT(IFcentre_de_gravite_____ponderation_GX,FZERO)));
DEFV(Common,DEFV(Float,SINT(IFcentre_de_gravite_____ponderation_GY,FZERO)));
DEFV(Common,DEFV(Float,INIT(IFcentre_de_gravite_____coordonnee_X,FLOT__UNDEF)));
DEFV(Common,DEFV(Float,INIT(IFcentre_de_gravite_____coordonnee_Y,FLOT__UNDEF)));
DEFV(Common,DEFV(FonctionF,IFcentre_de_gravite(imageA)))
/* Fonction introduite le 20220204173407... */
DEFV(Argument,DEFV(imageF,imageA));
/* Image Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
/*..............................................................................................................................*/
CALCUL_D_UN_CENTRE_DE_GRAVITE(imageA
,loadF_point
,genere_Float
,IFcentre_de_gravite_____seuil
,IFcentre_de_gravite_____coordonnee_X
,IFcentre_de_gravite_____coordonnee_Y
);
RETU(LIZ2(IFcentre_de_gravite_____ponderation_GX,IFcentre_de_gravite_____coordonnee_X
,IFcentre_de_gravite_____ponderation_GY,IFcentre_de_gravite_____coordonnee_Y
)
);
Eblock
EFonctionF
#undef CALCUL_D_UN_CENTRE_DE_GRAVITE
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N A L B U M S T A N D A R D : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Acomptage_des_points_dans_un_intervalle(albumA1,niveau_origine,niveau_extremite)))
DEFV(Argument,DEFV(album,albumA1));
/* Album Argument, */
DEFV(Argument,DEFV(genere_p,niveau_origine));
DEFV(Argument,DEFV(genere_p,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
begin_album
Bblock
Test(IFINff(Aload_point(albumA1,X,Y,Z),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_album
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'album Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,AFcomptage_des_points_dans_un_intervalle(albumA1,niveau_origine,niveau_extremite)))
DEFV(Argument,DEFV(albumF,albumA1));
/* Album Argument, */
DEFV(Argument,DEFV(genere_Float,niveau_origine));
DEFV(Argument,DEFV(genere_Float,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
begin_album
Bblock
Test(IFINff(AloadF_point(albumA1,X,Y,Z),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_album
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'album Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E P O I N T S */
/* A P P A R T E N A N T A U N C E R T A I N I N T E R V A L L E */
/* D A N S U N D O M A I N E P A R A L L E P I P E D I Q U E D ' U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,AFdomaine_comptage_des_points_dans_un_intervalle(albumA1
,domaine_Xmin,domaine_Xmax
,domaine_Ymin,domaine_Ymax
,domaine_Zmin,domaine_Zmax
,niveau_origine
,niveau_extremite
)
)
)
DEFV(Argument,DEFV(albumF,albumA1));
/* Album Argument, */
DEFV(Argument,DEFV(Int,domaine_Xmin));
DEFV(Argument,DEFV(Int,domaine_Xmax));
DEFV(Argument,DEFV(Int,domaine_Ymin));
DEFV(Argument,DEFV(Int,domaine_Ymax));
DEFV(Argument,DEFV(Int,domaine_Zmin));
DEFV(Argument,DEFV(Int,domaine_Zmax));
/* Definition du domaine parallepipedique... */
DEFV(Argument,DEFV(genere_Float,niveau_origine));
DEFV(Argument,DEFV(genere_Float,niveau_extremite));
/* Definition de l'intervalle de comptage (bornes incluses, voir le 'IFINff(...)' utilise, */
/* ce qui permet de reduire l'intervalle a un point par : niveau_origine=niveau_extremite). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_points,ZERO));
/* Nombre de points dans l'intervalle (initialement, aucun). */
/*..............................................................................................................................*/
begin_albumQ(DoIn,MAX2(Zmin,domaine_Zmin),MIN2(Zmax,domaine_Zmax),PasZ
,DoIn,MAX2(Ymin,domaine_Ymin),MIN2(Ymax,domaine_Ymax),PasY
,DoIn,MAX2(Xmin,domaine_Xmin),MIN2(Xmax,domaine_Xmax),PasX
)
Bblock
Test(IFINff(AloadF_point(albumA1,X,Y,Z),niveau_origine,niveau_extremite))
Bblock
INCR(nombre_de_points,I);
/* Comptage des points appartenant a l'intervalle Argument. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_albumQ(EDoD,EDoD,EDoD)
RETU(nombre_de_points);
/* Et renvoi du nombre de points dans l'intervalle dans l'album Argument. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E C O I N C I D E N C E S */
/* E N T R E D E U X A L B U M S S T A N D A R D : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Acomptage_des_coincidences(albumA1,albumA2)))
DEFV(Argument,DEFV(album,albumA1));
/* Premier album Argument, */
DEFV(Argument,DEFV(album,albumA2));
/* Deuxieme album Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_coincidences,ZERO));
/* Nombre de coincidences entre les deux albums arguments (initialement, aucune). */
/*..............................................................................................................................*/
begin_album
Bblock
Test(IFEQ(Aload_point(albumA1,X,Y,Z),Aload_point(albumA2,X,Y,Z)))
Bblock
INCR(nombre_de_coincidences,I);
/* Comptage des coincidences entre les deux albums arguments. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_album
RETU(nombre_de_coincidences);
/* Et renvoi du nombre de coincidences entre les deux albums arguments. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D U N O M B R E D E C O I N C I D E N C E S */
/* E N T R E D E U X A L B U M S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,AFcomptage_des_coincidences(albumA1,albumA2)))
DEFV(Argument,DEFV(albumF,albumA1));
/* Premier album Argument, */
DEFV(Argument,DEFV(albumF,albumA2));
/* Deuxieme album Argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Positive,INIT(nombre_de_coincidences,ZERO));
/* Nombre de coincidences entre les deux albums arguments (initialement, aucune). */
/*..............................................................................................................................*/
begin_album
Bblock
Test(IFEQ(AloadF_point(albumA1,X,Y,Z),AloadF_point(albumA2,X,Y,Z)))
Bblock
INCR(nombre_de_coincidences,I);
/* Comptage des coincidences entre les deux albums arguments. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_album
RETU(nombre_de_coincidences);
/* Et renvoi du nombre de coincidences entre les deux albums arguments. */
Eblock
EFonctionI
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E C H E R C H E D E S C O O R D O N N E E S E X T R E M A L E S */
/* D E S P O I N T N ' A P P A R T E N A N T P A S A U F O N D : */
/* */
/*************************************************************************************************************************************/
BFonctionL
#define RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y(begin_1,begin_2,on_a_trouve__un_extremum,extremum,coordonnee,end_2,end_1) \
Bblock \
begin_1 \
Bblock \
begin_2 \
Bblock \
Test(EST_FAUX(on_a_trouve__un_extremum)) \
Bblock \
DEFV(genere_p,INIT(niveau_courant,load_point(imageA,X,Y))); \
/* Recuperation du niveau courant en {X,Y}. */ \
Test(IFNE(niveau_courant,Icoordonnees_extremales_____niveau_du_fond)) \
Bblock \
EGAL(extremum,coordonnee); \
EGAL(on_a_trouve__un_extremum,VRAI); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
end_2 \
Eblock \
end_1 \
Eblock
DEFV(Common,DEFV(genere_p,SINT(Icoordonnees_extremales_____niveau_du_fond,NOIR)));
/* Definition du fond... */
DEFV(Common,DEFV(Logical,SINT(Icoordonnees_extremales_____on_a_trouve__Xminimum,FAUX)));
DEFV(Common,DEFV(Int,SINT(Icoordonnees_extremales_____Xminimum,NIVEAU_UNDEF)));
DEFV(Common,DEFV(Logical,SINT(Icoordonnees_extremales_____on_a_trouve__Xmaximum,FAUX)));
DEFV(Common,DEFV(Int,SINT(Icoordonnees_extremales_____Xmaximum,NIVEAU_UNDEF)));
DEFV(Common,DEFV(Logical,SINT(Icoordonnees_extremales_____on_a_trouve__Yminimum,FAUX)));
DEFV(Common,DEFV(Int,SINT(Icoordonnees_extremales_____Yminimum,NIVEAU_UNDEF)));
DEFV(Common,DEFV(Logical,SINT(Icoordonnees_extremales_____on_a_trouve__Ymaximum,FAUX)));
DEFV(Common,DEFV(Int,SINT(Icoordonnees_extremales_____Ymaximum,NIVEAU_UNDEF)));
DEFV(Common,DEFV(FonctionL,Icoordonnees_extremales(imageA)))
/* Fonction introduite le 20190112121122... */
DEFV(Argument,DEFV(image,imageA));
/* Image argument. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
/*..............................................................................................................................*/
RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y(begin_ligne,begin_colonne
,Icoordonnees_extremales_____on_a_trouve__Xminimum,Icoordonnees_extremales_____Xminimum,X
,end_colonne,end_ligne
);
RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y(begin_ligne_back,begin_colonne
,Icoordonnees_extremales_____on_a_trouve__Xmaximum,Icoordonnees_extremales_____Xmaximum,X
,end_colonne,end_ligne_back
);
RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y(begin_colonne,begin_ligne
,Icoordonnees_extremales_____on_a_trouve__Yminimum,Icoordonnees_extremales_____Yminimum,Y
,end_ligne,end_colonne
);
RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y(begin_colonne_back,begin_ligne
,Icoordonnees_extremales_____on_a_trouve__Ymaximum,Icoordonnees_extremales_____Ymaximum,Y
,end_ligne,end_colonne_back
);
RETU(IFOU(IFOU(EST_FAUX(Icoordonnees_extremales_____on_a_trouve__Xminimum)
,EST_FAUX(Icoordonnees_extremales_____on_a_trouve__Xmaximum)
)
,IFOU(EST_FAUX(Icoordonnees_extremales_____on_a_trouve__Yminimum)
,EST_FAUX(Icoordonnees_extremales_____on_a_trouve__Ymaximum)
)
)
);
Eblock
EFonctionL
#undef RECHERCHE_DES_EXTREMA_DE_X_ET_DE_Y
_______________________________________________________________________________________________________________________________________
Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.