/*************************************************************************************************************************************/
/* */
/* I N T E G R A T I O N D ' U N E S E R I E D ' I M A G E S P A R S U I V I D U G R A D I E N T */
/* T R I - D I M E N S I O N N E L E T " B R O U I L L A G E " D ' U N E I M A G E : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande parcourt d'avant (la premiere */
/* image) en arriere (la derniere image) une */
/* serie d'images ; ce suivi se fait en calculant */
/* les gradients locaux : il s'agit un peu d'un */
/* "Ray Tracing" a l'interieur d'un milieu d'indice */
/* variable. Le resultat est une image vue a travers */
/* ce milieu. */
/* */
/* */
/* Author of '$xci/integre.03$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1989??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define FACTEUR_MULTIPLICATIF_DU_GRADIENT \
FRA16(FRA16(FU)) \
/* Pour accentuer ou diminuer les effets du gradient. */
#define SENS_DIRECT \
VRAI \
/* Cet indicateur precise le sens du brouillage : */ \
/* */ \
/* VRAI : imageR[brouillage(X)][brouillage(Y)]=imageA[X][Y], */ \
/* FAUX : imageR[X][Y]=imageA[brouillage(X)][brouillage(Y)]. */ \
/* */
#define MARQUER_LES_POINTS_ATTEINTS \
FAUX \
/* Cet indicateur precise s'il faut ('VRAI') ou pas ('FAUX') generer une image 'Marqueur' */ \
/* indiquant quels sont les points non atteints par le brouillage... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define LOAD_AND_BROUILLE(imageA1,imageA2,imageA3) \
Bblock \
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(imageA3,nom_image)))) \
Bblock \
/* 'ImageA3' donne la couche a l'instant courant. */ \
Eblock \
ATes \
Bblock \
Test__CODE_ERREUR__ERREUR07; \
Eblock \
ETes \
CALS(Isuivi_du_gradient(matrice_de_brouillage,facteur_multiplicatif_du_gradient,imageA1,imageA2,imageA3)); \
/* Traitement des trois images courantes. */ \
Eblock \
/* Chargement de l'image courante, et traitement avec les deux precedentes. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E G R A T I O N D ' U N E S E R I E D ' I M A G E S P A R S U I V I D U G R A D I E N T */
/* T R I - D I M E N S I O N N E L E T " B R O U I L L A G E " D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageM),NOM_PIPE));
/* Nom du Marqueur des points brouilles. */
DEFV(CHAR,INIC(POINTERc(nom_imageB),NOM_PIPE));
/* Nom de l'image a Brouiller. */
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
/* Nom de la sequence a integrer. */
DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_imageA><numero> (par exemple '$ROUGE'). */
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom du Resultat de l'integration. */
DEFV(Int,INIT(premiere_image,FLOT(PREMIERE_IMAGE)));
/* Numero de la premiere image, */
DEFV(Int,INIT(derniere_image,FLOT(DERNIERE_IMAGE)));
/* Numero de la derniere image. */
DEFV(Int,INIT(pas_des_images,FLOT(PAS_DES_IMAGES)));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(Int,INIT(numero_d_image,UNDEF));
/* Numero de l'image courante. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Float,INIT(facteur_multiplicatif_du_gradient,FACTEUR_MULTIPLICATIF_DU_GRADIENT));
/* Pour accentuer ou diminuer les effets du gradient. */
DEFV(Logical,INIT(sens_direct,SENS_DIRECT));
/* Cet indicateur precise le sens du brouillage : */
/* */
/* VRAI : imageR[brouillage(X)][brouillage(Y)]=imageA[X][Y], */
/* FAUX : imageR[X][Y]=imageA[brouillage(X)][brouillage(Y)]. */
/* */
DEFV(Logical,INIT(marquer_les_points_atteints,MARQUER_LES_POINTS_ATTEINTS));
/* Cet indicateur precise s'il faut ('VRAI') ou pas ('FAUX') generer une image 'Marqueur' */
/* indiquant quels sont les points non atteints par le brouillage... */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("postfixe=",nom_postfixe);
GET_ARGUMENT_C("imageB=""B=",nom_imageB);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_C("imageM=""M=",nom_imageM);
GET_ARGUMENT_I("premiere=",premiere_image);
GET_ARGUMENT_I("derniere=",derniere_image);
GET_ARGUMENT_I("pas=",pas_des_images);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_F("facteur=""f=",facteur_multiplicatif_du_gradient);
GET_ARGUMENT_L("sens=""direct=",sens_direct);
GET_ARGUMENT_L("marquage=",marquer_les_points_atteints);
)
);
SET_ECHANTILLONNAGE_DE_PROFONDEUR(SCAL(PasZ,DIVI(LENG(premiere_image,derniere_image),pas_des_images),dimZ));
/* Mise en place du pas d'echantillonnage le long de 'OZ'. */
begin_nouveau_block
Bblock
BDEFV(imageJ,matrice_de_brouillage);
/* Matrice de brouillage obtenue par "intergation" de la sequence Argument. */
CALS(IJinitialisation_matrice_de_brouillage(matrice_de_brouillage));
/* Initialisation de la matrice de "brouillage" (etat "neutre"). */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageB))))
Bblock
/* 'ImageA' donne l'image a Brouiller. */
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
Test(IFNE(numero_d_image,fINTE(numero_d_image)))
Bblock
PRINT_ATTENTION("le numero de l'image courante n'est pas entier et va donc etre tronque");
Eblock
ATes
Bblock
Eblock
ETes
EGAL(nom_image
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(INTE(numero_d_image),nombre_de_chiffres)
)
,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(INTE(numero_d_image),nombre_de_chiffres)
,nom_postfixe
)
)
);
/* Le 20221212115105, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Choi(REST(SOUS(numero_d_image,premiere_image),TROIS))
Bblock
Ca1e(ZERO)
Bblock
LOAD_AND_BROUILLE(ImageA2,ImageA3,ImageA1);
/* Traitement des images (2,3,1). */
Eblock
ECa1
Ca1e(UN)
Bblock
LOAD_AND_BROUILLE(ImageA3,ImageA1,ImageA2);
/* Traitement des images (3,1,2). */
Eblock
ECa1
Ca1e(DEUX)
Bblock
LOAD_AND_BROUILLE(ImageA1,ImageA2,ImageA3);
/* Traitement des images (1,2,3). */
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("le reste a une valeur bizarre");
Eblock
EDef
Eblock
ECho
CALZ_FreCC(nom_image);
Eblock
EDoI
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALS(Ibrouillage(ImageR,ImageA,matrice_de_brouillage,sens_direct,marquer_les_points_atteints));
/* Et enfin, "brouillage" de l'image argument... */
CALi(Iupdate_image(nom_imageR,ImageR));
Test(IL_FAUT(marquer_les_points_atteints))
Bblock
CALi(Iupdate_image(nom_imageM,Marqueur));
/* Sauvegarde des points atteints... */
Eblock
ATes
Bblock
Eblock
ETes
EDEFV(imageJ,matrice_de_brouillage);
/* Matrice de brouillage obtenue par "integration" de la sequence Argument. */
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande