/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D ' U N E S E R I E D ' I M A G E S */
/* D U T Y P E " T R A N S P A R E N C E " : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande "accumule" une serie d'images */
/* en effectuant, suivant les options donnees */
/* les operations suivantes ('i' designant un */
/* indice de parcours des listes 'Image1' et 'Image2') : */
/* */
/* Cumul <-- maximum(Cumul,Image1(i)*Image2(i)) */
/* */
/* et/ou : */
/* */
/* Cumul <-- Cumul + Image1(i)*Image2(i) */
/* */
/* et/ou : */
/* */
/* Cumul <-- Cumul * Image1(i)*Image2(i) */
/* */
/* les trois operations pouvent etre effectuees les unes */
/* apres les autres (1 parmi 3, 2 parmi 3 ou */
/* les 3...) et ce dans l'ordre indique ci-dessus. */
/* */
/* */
/* Author of '$xci/accumule.31$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20040929090731). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_IMAGESF_EXT
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES \
FAUX \
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */ \
/* */ \
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */ \
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */ \
/* */
#include xci/accumule.03.I"
#define FAIRE_UNE_SOMME \
VRAI \
/* Faut-il sommer ("+") les differentes images entre-elles ('VRAI') ou pas ('FAUX') ? */
#define FAIRE_UN_PRODUIT \
FAUX \
/* Faut-il multiplier ("*") les differentes images entre-elles ('VRAI') ou pas ('FAUX') ? */
#define NORMALISER_LE_CUMUL \
VRAI \
/* Faut-il normaliser le cumul en fonction du nombre d'images accumulees ('VRAI') ou pas */ \
/* ('FAUX'). */
#define PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE \
FAUX \
/* Faut-il prendre une dynamique logarithmique ('VRAI') ou laisser les accumulations telles */ \
/* qu'elles ont ete calculees ('FAUX') ? ATTENTION, ceci n'a de sens que lorsque l'on */ \
/* procede par cumul arithmetique (voir 'RECHERCHE_DU_MAXIMUM'), et de plus, lorsque le */ \
/* logarithme est utilise, la renormalisation est forcee... */
#include xci/accumule.01.I"
#define PAS_HORIZONTAL \
_____lNORMALISE_OX(ZERO)
#define PAS_VERTICAL \
_____lNORMALISE_OY(ZERO)
/* Pas de decalage des differentes images... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#include xci/accumule.04.I"
#define NOM_IMAGE_COURANTE(nom_image,nom_imageA) \
Bblock \
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 20221212114915, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */ \
Eblock \
/* Generation du nom de l'image courante... */
#define TRAITEMENT_DE_LA_COUCHE_COURANTE(image1,image2) \
Bblock \
CALi(IFinitialisation(image2,FZERO)); \
/* On ne sait jamais... */ \
\
Test(IL_FAUT(faire_une_complementation)) \
Bblock \
CALS(IFcomplementation(image2,image1)); \
CALS(IFmove(image1,image2)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(faire_une_symetrie_OX)) \
Bblock \
CALS(IFx_symetrie(image2,image1)); \
CALS(IFmove(image1,image2)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(faire_une_symetrie_OY)) \
Bblock \
CALS(IFy_symetrie(image2,image1)); \
CALS(IFmove(image1,image2)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALi(IFinitialisation(image2,FZERO)); \
/* Nettoyage systematique de 'image2' a cause du fait que la translation peut etre non */ \
/* nulle (on risque alors de recuperer des morceaux du contenu anterieur de 'image2'). */ \
CALS(IFtranslation(image2 \
,image1 \
,ADRESSE(RRtranslation) \
,FAUX \
,FAUX \
) \
); \
/* Et on decale l'image courante... */ \
Eblock \
/* Traitement de la couche courante... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D ' U N E S E R I E D ' I M A G E S */
/* D U T Y P E " T R A N S P A R E N C E " : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageA1),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA2),NOM_PIPE));
/* Nom des deux sequences a integrer. */
DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_image?><numero> (par exemple '$ROUGE'). */
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom du Resultat de l'integration. */
DEFV(genere_Float,INIT(premiere_image,FLOT(PREMIERE_IMAGE)));
/* Numero de la premiere image, */
DEFV(genere_Float,INIT(derniere_image,FLOT(DERNIERE_IMAGE)));
/* Numero de la derniere image. */
DEFV(Int,INIT(translation_des_numeros_des_images,TRANSLATION_DES_NUMEROS_DES_IMAGES));
/* Les numeros d'images peuvent etre translates. Lorsque tel est le cas, le numero */
/* d'image utilise est le numero translate modulo {premiere,derniere}. */
DEFV(Logical,INIT(inverser_l_ordre_de_recuperation_des_images,INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES));
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */
/* */
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */
/* */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(genere_Float,INIT(numero_d_image,FLOT__UNDEF));
/* Numero de l'image courante. */
DEFV(genere_Float,INIT(pas_des_images,FLOT(PAS_DES_IMAGES)));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(CHAR,INIT(POINTERc(nom_image1),NOM_UNDEF));
DEFV(CHAR,INIT(POINTERc(nom_image2),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Int,INIT(nombre_d_images_traitees,ZERO));
/* Nombre d'images reellement traitees. */
DEFV(Logical,INIT(normaliser_le_cumul,NORMALISER_LE_CUMUL));
/* Faut-il normaliser le cumul en fonction du nombre d'images accumulees ('VRAI') ou pas */
/* ('FAUX'). */
DEFV(Logical,INIT(prendre_une_dynamique_logarithmique,PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE));
/* Faut-il prendre une dynamique logarithmique ('VRAI') ou laisser les accumulations telles */
/* qu'elles ont ete calculees ('FAUX') ? ATTENTION, ceci n'a de sens que lorsque l'on */
/* procede par cumul arithmetique (voir 'RECHERCHE_DU_MAXIMUM'), et de plus, lorsque le */
/* logarithme est utilise, la renormalisation est forcee... */
DEFV(Logical,INIT(rechercher_le_maximum,RECHERCHE_DU_MAXIMUM));
/* Faut-il rechercher le maximum ('VRAI') des differentes images ou pas ('FAUX') ? */
DEFV(Logical,INIT(en_fait_rechercher_le_minimum,EN_FAIT_RECHERCHE_DU_MINIMUM));
/* Lorsque 'IL_FAUT(rechercher_le_maximum)', doit-on en fait chercher le minimum ('VRAI') */
/* ou bien (comme avant le 19990323143608) veritablement le maximum ('FAUX') ? On notera */
/* l'interet de cette option avec les images qui sont sur un fond BLANC (apres, par exemple, */
/* l'intervention de '$xci/complement$X'). On verra avec interet 'v $xiirv/PART.41.1.0'. */
DEFV(Logical,INIT(faire_une_somme,FAIRE_UNE_SOMME));
/* Faut-il sommer ("+") les differentes images entre-elles ('VRAI') ou pas ('FAUX') ? */
DEFV(Logical,INIT(faire_un_produit,FAIRE_UN_PRODUIT));
/* Faut-il multiplier ("*") les differentes images entre-elles ('VRAI') ou pas ('FAUX') ? */
DEFV(deltaF_2D,Atranslation);
DEFV(deltaF_2D,RAtranslation);
DEFV(deltaF_2D,RRtranslation);
/* Translation verticale d'empilement des images... */
DEFV(Logical,INIT(faire_une_complementation,FAIRE_UNE_COMPLEMENTATION));
/* Faut-il faire une complementation ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit le */
/* 20030317143127. */
DEFV(Logical,INIT(faire_une_symetrie_OX,FAIRE_UNE_SYMETRIE_OX));
DEFV(Logical,INIT(faire_une_symetrie_OY,FAIRE_UNE_SYMETRIE_OY));
/* Faut-il faire des symetries ('VRAI') ou pas ('FAUX') ? */
DEFV(Float,INIT(pas_horizontal,FLOT__UNDEF));
DEFV(Float,INIT(pas_vertical,FLOT__UNDEF));
/* Pas de variation de la translation verticale d'empilement des images... */
DEFV(Float,INIT(facteur_stereoscopique,FACTEUR_STEREOSCOPIQUE));
/* Facteur destine a simplifier la production de couples stereoscopiques. En general, trois */
/* valeurs seront utiles : */
/* */
/* FZERO */
/* NEUT(FU) */
/* NEGA(FU) */
/* */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA1=""A1=",nom_imageA1);
GET_ARGUMENT_C("imageA2=""A2=",nom_imageA2);
GET_ARGUMENT_C("postfixe=",nom_postfixe);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_F("premiere=",premiere_image);
GET_ARGUMENT_F("derniere=",derniere_image);
GET_ARGUMENT_F("pas=",pas_des_images);
GET_ARGUMENT_I("modulo=",translation_des_numeros_des_images);
GET_ARGUMENT_L("inverser=",inverser_l_ordre_de_recuperation_des_images);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_L("normaliser=",normaliser_le_cumul);
GET_ARGUMENT_L("logarithmique=""log=",prendre_une_dynamique_logarithmique);
GET_ARGUMENT_L("maximum=",rechercher_le_maximum);
GET_ARGUMENT_L("minimum=",en_fait_rechercher_le_minimum);
GET_ARGUMENT_L("somme=""s=",faire_une_somme);
GET_ARGUMENT_L("produit=""p=",faire_un_produit);
GET_ARGUMENT_L("complementer=""complement=""comp=",faire_une_complementation);
GET_ARGUMENT_L("SX=",faire_une_symetrie_OX);
GET_ARGUMENT_L("SY=",faire_une_symetrie_OY);
GIT_ARGUMENT_F("trx=",pas_horizontal,PAS_HORIZONTAL);
GIT_ARGUMENT_F("try=",pas_vertical,PAS_VERTICAL);
GET_ARGUMENT_F("stereo=""Sfacteur=",facteur_stereoscopique);
/* Le 20050623144848, "facteur=" a ete remplace par "Sfacteur=" (double definition...). */
)
);
begin_nouveau_block
Bblock
BDEFV(imageF,cumul_des_couches);
/* Image flottante dans laquelle on cumule les differentes couches d'avant en arriere. */
BDEFV(imageF,couche_courante);
/* Image flottante dans laquelle on trouve la couche courante. */
INITIALISATION_ACCROISSEMENT_2D(Atranslation
,FZERO
,FZERO
);
INITIALISATION_ACCROISSEMENT_2D(RAtranslation
,FZERO
,FZERO
);
INITIALISATION_ACCROISSEMENT_2D(RRtranslation
,NEUT(MUL2(VRAI_PAS_HORIZONTAL,MOIT(LENG(premiere_image,derniere_image))))
,NEUT(MUL2(VRAI_PAS_VERTICAL,MOIT(LENG(premiere_image,derniere_image))))
);
/* Definition de la translation d'empilement vertical des images. La valeur initiale de */
/* 'RRtranslation' est faite de facon a ce que le "centre" de l'objet tridimensionnel obtenu */
/* par accumulation tombe au centre de l'image... */
CALi(IFinitialisation(cumul_des_couches
,COND(I3ET(IL_NE_FAUT_PAS(rechercher_le_maximum)
,IL_NE_FAUT_PAS(faire_une_somme)
,IL_FAUT(faire_un_produit)
)
,FU
,COND(IFET(IL_FAUT(rechercher_le_maximum)
,IL_FAUT(en_fait_rechercher_le_minimum)
)
,FU
,FZERO
)
)
)
);
/* Nettoyage de l'image finale flottante... */
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
NOM_IMAGE_COURANTE(nom_image1,nom_imageA1);
NOM_IMAGE_COURANTE(nom_image2,nom_imageA2);
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA1,nom_image1))))
Bblock
/* 'IFmageA1' donne la couche 1 a l'instant courant, */
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA2,nom_image2))))
Bblock
/* 'IFmageA2' donne la couche 2 a l'instant courant, */
TRAITEMENT_DE_LA_COUCHE_COURANTE(IFmageA1,IFmageA3);
TRAITEMENT_DE_LA_COUCHE_COURANTE(IFmageA2,IFmageA4);
/* Traitement des deux couches courantes... */
CALS(IFmultiplication(couche_courante
,IFmageA3
,IFmageA4
)
);
/* Attenuation eventuelle de la couche courante... */
Test(IL_FAUT(rechercher_le_maximum))
Bblock
Test(IL_NE_FAUT_PAS(en_fait_rechercher_le_minimum))
Bblock
CALS(IFmaximum(cumul_des_couches,cumul_des_couches,couche_courante));
/* Et on cumule d'avant en arriere par recherche du maximum. */
Eblock
ATes
Bblock
CALS(IFminimum(cumul_des_couches,cumul_des_couches,couche_courante));
/* Et on cumule d'avant en arriere par recherche du minimum. */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_une_somme))
Bblock
CALS(IFaddition(cumul_des_couches,cumul_des_couches,couche_courante));
/* Et on cumule d'avant en arriere par addition arithmetique. */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_un_produit))
Bblock
CALS(IFmultiplication(cumul_des_couches,cumul_des_couches,couche_courante));
/* Et on cumule d'avant en arriere par produit arithmetique. */
Eblock
ATes
Bblock
Eblock
ETes
DECR(ASD1(RRtranslation,dx),MUL2(FLOT(pas_des_images),VRAI_PAS_HORIZONTAL));
DECR(ASD1(RRtranslation,dy),MUL2(FLOT(pas_des_images),VRAI_PAS_VERTICAL));
/* Et on decale d'un cran de plus... */
INCR(nombre_d_images_traitees,I);
/* Et comptage du nombre d'images reellement traitees. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_image1);
Eblock
EDoI
Test(IL_FAUT(prendre_une_dynamique_logarithmique))
Bblock
CALS(IFdynamique_logarithmique_avec_translation_dynamique(cumul_des_couches,cumul_des_couches));
/* S'il le faut, la dynamique des accumulations est reduite par application d'une fonction */
/* logarithme... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(normaliser_le_cumul))
Bblock
CALS(IFscale(IFmageR
,INVZ(FLOT(nombre_d_images_traitees))
,cumul_des_couches
,FZERO
)
);
/* Renormalisation en fonction du nombre d'images traitees. On notera l'usage de 'INVZ(...)' */
/* au cas ou il y aurait eu erreur sur toutes les images recuperees... */
Eblock
ATes
Bblock
CALS(IFmove(IFmageR
,cumul_des_couches
)
);
/* Pas de renormalisation... */
Eblock
ETes
CALi(IupdateF_image(nom_imageR,IFmageR));
EDEFV(imageF,couche_courante);
/* Image flottante dans laquelle on trouve la couche courante. */
EDEFV(imageF,cumul_des_couches);
/* Image flottante dans laquelle on cumule les differentes couches d'avant en arriere. */
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande