/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D Y N A M I Q U E 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 */
/* sous forme d'une autre serie d'images, chacune */
/* d'elles etant la "somme" de plusieurs de la */
/* premiere serie. Elle effectue l'operation */
/* suivante ('j' et 'i' designant deux indices */
/* de parcours des listes 'Cumul' et 'Image') : */
/* */
/* Cumul(j) <-- Cumul(j) + ponderation*Image(i) */
/* */
/* */
/* Author of '$xci/accumule.11$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1990??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CPP_____POUR_LES_Iload_NE_PAS_VERIFIER_LES_MULTIPLES_UTILISATIONS_DE_L_IMAGE_____ImageA
/* Introduit le 20060124091906. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 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 NOMBRE_D_IMAGES_A_INTEGRER \
I \
/* Nombre d'images a integrer pour calculer la suite Resultat. */
#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, lorsque le logarithme est utilise, la */ \
/* renormalisation est forcee... */
#define IL_FAUT_RENORMALISER \
FAUX \
/* Faut-il renormaliser l'image ? */
#include xci/accumule.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#define N_IMAGES_INTEGREES \
FLOT(nombre_d_images_a_integrer) \
/* Tout cela pour raccoucir les lignes de 'chain_Aconcaten2_sauf_nom_pipe(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D Y N A M I Q U E 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_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'), */
/* et aussi derriere <nom_imageR><numero> contrairement aux programmes '$xci/accumule.01$K' */
/* '$xci/accumule.02$K'... */
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(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, lorsque le logarithme est utilise, la */
/* renormalisation est forcee... */
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(Int,INIT(nombre_d_images_a_integrer,NOMBRE_D_IMAGES_A_INTEGRER));
/* Nombre d'images a integrer pour calculer la suite Resultat. */
DEFV(Int,INIT(nombre_d_images_traitees,ZERO));
/* Nombre d'images reellement traitees. Ce parametre est utilise pour le calcul du */
/* facteur de renormalisation, et n'est mis a jour que pour les premieres images, soit */
/* 'nombre_d_images_a_integrer'... */
DEFV(CHAR,INIT(POINTERc(nom_imageA_j),NOM_UNDEF));
DEFV(CHAR,INIT(POINTERc(nom_imageA_j_p),NOM_UNDEF));
DEFV(CHAR,INIT(POINTERc(nom_imageR_j),NOM_UNDEF));
/* Noms courant des images. */
DEFV(Float,INIT(facteur_d_attenuation,FACTEUR_D_ATTENUATION));
/* Facteur destine a attenuer (eventuellement) les images, la premiere etant en general */
/* plus attenuee que la derniere, car elle correspond dans une sequence temporelle a un */
/* instant plus ancien (la valeur 'FU' correspond a l'absence...). On notera que si : */
/* */
/* (derniere_image - premiere_image + 1) */
/* BLANC*(facteur_d_attenuation) = 1 */
/* */
/* on exploite alors au mieux la dynamique des niveaux de gris, la derniere image se */
/* trouvant tres pres du NOIR. A titre d'exemple, lors d'un calcul portant sur 128 */
/* images, on a : */
/* */
/* facteur_d_attenuation = 0.957633 */
/* */
DEFV(Logical,INIT(editer_le_facteur_d_attenuation,EDITER_LE_FACTEUR_D_ATTENUATION));
/* Indique s'il faut editer ('VRAI') ou pas ('FAUX') le facteur d'attenuation ; cela n'a */
/* evidemment de sens que lorsque celui est nul, et donc calcule automatiquement... */
DEFV(Float,INIT(attenuation_globale,FZERO));
/* Cumul ponderes des 'facteur_d_attenuation' afin de calculer l'image finale lorsqu'il */
/* n'y a pas de renormalisation automatique... */
/*..............................................................................................................................*/
EGAL(les_images_standards_sont_a_renormaliser,IL_FAUT_RENORMALISER);
/* Faut-il renormaliser l'image ? */
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
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_I("nombre=""n=",nombre_d_images_a_integrer);
GET_ARGUMENT_F("fa=""attenuation=""a=",facteur_d_attenuation);
GET_ARGUMENT_L("editer=",editer_le_facteur_d_attenuation);
/* Argument introduit le 20091103180310... */
GET_ARGUMENT_L("logarithmique=""log=",prendre_une_dynamique_logarithmique);
GET_ARGUMENT_L("rn=""renormaliser=""r=",les_images_standards_sont_a_renormaliser);
)
);
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, puis a la fin le */
/* resultat renormalise par le nombre d'images... */
Test(IZEQ(facteur_d_attenuation))
Bblock
EGAL(facteur_d_attenuation,PUIX(INVE(FLOT__BLANC),INVZ(NBRE(premiere_image,derniere_image))));
/* Lorsque le facteur d'attenuation est nul, il est alors calcule automatiquement de */
/* facon que : */
/* */
/* (derniere_image - premiere_image + 1) */
/* BLANC.(facteur_d_attenuation) = 1. */
/* */
/* A titre d'exemple, lors d'un calcul portant sur 128 images, on a : */
/* */
/* facteur_d_attenuation = 0.957633 */
/* */
Test(IL_FAUT(editer_le_facteur_d_attenuation))
Bblock
CAL3(Prme1("facteur d'attenuation effectif : %.^^^\n",facteur_d_attenuation));
/* Le 20091123123203, le format "^^g" est passe a "^^^" pour plus de souplesse... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
CALi(IFinitialisation(cumul_des_couches,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
EGAL(nom_imageA_j
,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 20221212114537, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageA_j))))
Bblock
/* 'ImageA' donne la couche a l'instant courant, */
CALS(Istd_float(couche_courante
,FLOT__NOIR
,FLOT__BLANC
,ImageA
)
);
/* Conversion flottante avec attenuation eventuelle... */
CALS(IFscale(cumul_des_couches
,facteur_d_attenuation
,cumul_des_couches
,FZERO
)
);
CALS(IFaddition(cumul_des_couches,cumul_des_couches,couche_courante));
/* On realise systematiquement l'operation : */
/* */
/* R = k.R + I */
/* j j-1 j */
/* */
/* ou 'R' designe le cumul a l'"instant" 'j', et 'I' l'image courante. */
Test(IFGT(TRPU(INTE(SOUS(numero_d_image,premiere_image)))
,N_IMAGES_INTEGREES
)
)
Bblock
EGAL(nom_imageA_j_p
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(INTE(SOUS(numero_d_image,N_IMAGES_INTEGREES))
,nombre_de_chiffres
)
)
,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(INTE(SOUS(numero_d_image,N_IMAGES_INTEGREES))
,nombre_de_chiffres
)
,nom_postfixe
)
)
);
/* Le 20221212114537, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_imageA_j_p))))
Bblock
/* 'ImageA' donne la couche a l'instant courant 'j' moins le nombre d'images a integrer 'p'. */
CALS(Istd_float(couche_courante
,FLOT__NOIR
,FLOT__BLANC
,ImageA
)
);
CALS(IFscale(couche_courante
,NEGA(PUIX(facteur_d_attenuation,nombre_d_images_a_integrer))
,couche_courante
,FZERO
)
);
CALS(IFaddition(cumul_des_couches,cumul_des_couches,couche_courante));
/* Puis, pour j>p, on realise le cumul proprement dit, soit, en reprenant la formule */
/* precedente : */
/* */
/* p */
/* R = k.R + I - k .I */
/* j j-1 j j-p */
/* */
/* ou 'R' designe le cumul a l'"instant" 'j', et 'I' l'image courante. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_imageA_j_p);
Eblock
ATes
Bblock
EGAL(attenuation_globale
,AXPB(facteur_d_attenuation
,attenuation_globale
,FU
)
);
/* Cumul des coefficients d'attenuation courants suivant une formule identique a celle qui */
/* a ete utilisee pour les images, a savoir : */
/* */
/* R = k.R + I */
/* j j-1 j */
/* */
/* | | | */
/* | | | */
/* | | | */
/* */
/* A = k.A + 1 */
/* */
/* ou 'R' designe le cumul a l'"instant" 'j', 'I' l'image courante et 'A' l'attenuation. */
INCR(nombre_d_images_traitees,I);
/* Et comptage du nombre d'images reellement traitees dans la premiere phase. */
Eblock
ETes
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(IFOU(EST_VRAI(les_images_standards_sont_a_renormaliser)
,IL_FAUT(prendre_une_dynamique_logarithmique)
)
)
Bblock
CALS(Ifloat_std_avec_renormalisation(ImageR,cumul_des_couches));
/* De temps en temps, il peut etre utile de renormaliser, de facon a beneficier de toute */
/* la dynamique dans [NOIR,BLANC]... */
Eblock
ATes
Bblock
CALS(IFscale(couche_courante
,INVZ(attenuation_globale)
,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... */
CALS(Ifloat_std(ImageR,couche_courante,FLOT__NOIR,FLOT__BLANC));
/* Enfin, on convertit en une image standard sans renormalisation, et ce de facon a */
/* conserver la dynamique des images Arguments... */
Eblock
ETes
EGAL(nom_imageR_j
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
,chain_Aconcaten2_sauf_nom_pipe(nom_imageR
,chain_numero(INTE(numero_d_image),nombre_de_chiffres)
)
,chain_Aconcaten3_sauf_nom_pipe(nom_imageR
,chain_numero(INTE(numero_d_image),nombre_de_chiffres)
,nom_postfixe
)
)
);
CALi(Iupdate_image(nom_imageR_j,ImageR));
CALZ_FreCC(nom_imageR_j);
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_imageA_j);
Eblock
EDoI
EDEFV(imageF,couche_courante);
/* Image flottante dans laquelle on trouve la couche courante, puis a la fin le */
/* resultat renormalise par le nombre d'images... */
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