/*************************************************************************************************************************************/
/* */
/* 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 de la liste 'Image') : */
/* */
/* Cumul <-- maximum(Cumul,ponderation*Image(i)) */
/* */
/* et/ou : */
/* */
/* Cumul <-- Cumul + ponderation*Image(i) */
/* */
/* et/ou : */
/* */
/* Cumul <-- Cumul * ponderation*Image(i) */
/* */
/* la premiere image recuperee etant en general */
/* plus attenuee que la derniere. En ce qui */
/* concerne les images "standard", une seule de */
/* ces operations peut etre effectuee. Par contre, */
/* en ce qui concerne les images "non standard", 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. */
/* */
/* */
/* Note sur la generation de couples stereoscopiques : */
/* */
/* Pour generer un couple stereoscopique, il */
/* suffit de faire deux fois l'accumulation, */
/* c'est-a-dire une fois pour chaque oeil, avec */
/* les parametres suivants (pour 128 images) : */
/* */
/* $DROITE : translation_quelconque=VRAI try=0 trx=+5.0e-4 */
/* $GAUCHE : translation_quelconque=VRAI try=0 trx=-5.0e-4 */
/* */
/* lorsque l'on empile d'arriere en avant. Il faut noter que pour */
/* generer la vue de l'oeil '$DROITE' il faut decaler a gauche, alors */
/* que pour generer celle de l'oeil '$GAUCHE', il faut decaler a droite. */
/* Les signes de "trx=" sont inverses, car en effet, la variable */
/* 'RRtranslation' evolue a coup de 'DECR(...)', d'ou l'inversion des */
/* signes de "trx=". De plus, et dans ces conditions, il faudra faire */
/* tres ATTENTION au parametre "inverser=" (c'est-a-dire a la variable */
/* 'inverser_l_ordre_de_recuperation_des_images') qui alors a pour effet */
/* de permuter les vues des deux yeux. Pour plus de 128 images, il faudra */
/* reduire 'trx', et pour moins de 128 images, il faudra l'augmenter. */
/* */
/* */
/* Author of '$xci/accumule.01$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 : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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'). Cette option n'a de sens que pour "standard=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... */
#define IL_FAUT_RENORMALISER \
VRAI \
/* Faut-il renormaliser l'image ? ATTENTION, avant le 1994010500, cette constante prenait */ \
/* la valeur implicite 'FAUX'... */
#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"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_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(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(normaliser_le_cumul,NORMALISER_LE_CUMUL));
/* Faut-il normaliser le cumul en fonction du nombre d'images accumulees ('VRAI') ou pas */
/* ('FAUX'). Cette option n'a de sens que pour "standard=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(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_traitees,ZERO));
/* Nombre d'images reellement traitees. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Logical,INIT(faire_varier_lineairement_le_facteur_d_attenuation,FAIRE_VARIER_LINEAIREMENT_LE_FACTEUR_D_ATTENUATION));
/* Faut-il faire varier lineairement le 'facteur_d_attenuation_courant' ('VRAI') ou non */
/* lineairement ('FAUX') comme c'etait le cas systematiquement avant le 19990421143004. */
DEFV(Float,INIT(facteur_d_attenuation_de_depart,FACTEUR_D_ATTENUATION_DE_DEPART));
DEFV(Float,INIT(facteur_d_attenuation_d_arrivee,FACTEUR_D_ATTENUATION_D_ARRIVEE));
/* Bornes de variation de 'facteur_d_attenuation_courant' dans le cas ou */
/* 'IL_FAUT(faire_varier_lineairement_le_facteur_d_attenuation)'. */
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 ce */
/* facteur est nul, il est alors calcule automatiquement de facon que : */
/* */
/* (derniere_image - premiere_image + 1) */
/* BLANC*(facteur_d_attenuation) = 1 */
/* */
/* ce qui permet d'exploiter 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(facteur_A,FACTEUR_A));
DEFV(Float,INIT(facteur_B,FACTEUR_B));
/* Facteurs destines a transformer lineairement le numero d'image (A.n + B) */
DEFV(Float,INIT(facteur_d_attenuation_courant,FLOT__UNDEF));
/* Facteur d'attenuation de la couche courante qui vaut 'facteur_d_attenuation' eleve a */
/* une puissance qui est le rang de cette couche... */
DEFV(Float,INIT(attenuation_globale,FZERO));
/* Cumul des 'facteur_d_attenuation_courant's afin de calculer l'image finale lorsqu'il */
/* n'y a pas de renormalisation automatique... */
DEFV(deltaF_2D,Atranslation);
DEFV(deltaF_2D,RAtranslation);
DEFV(deltaF_2D,RRtranslation);
/* Translation verticale d'empilement des images... */
DEFV(Logical,INIT(translation_quelconque,TRANSLATION_QUELCONQUE));
/* Choix de la methode de translation de passage d'une couche a l'autre : */
/* */
/* FAUX : on utilise 'Itranslation(...)' qui est plus rapide, */
/* VRAI : on utilise 'Irotation_image(...)' qui est plus lent, mais presente l'avantage de */
/* permettre de faire une translation quelconque, et en particulier d'une fraction */
/* de point, ce qui autorise la production de couples stereoscopiques... */
/* */
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) */
/* */
/*..............................................................................................................................*/
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_L("standard=",les_images_sont_standards);
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("interpolation_cubique=""cubique=",Irotation_image_____interpolation_cubique);
GET_ARGUMENT_N("interpolation_lineaire=",Irotation_image_____interpolation_cubique);
/* Arguments introduits le 20131230130011... */
GET_ARGUMENT_L("lineaire=",faire_varier_lineairement_le_facteur_d_attenuation);
GET_ARGUMENT_F("depart=",facteur_d_attenuation_de_depart);
GET_ARGUMENT_F("arrivee=",facteur_d_attenuation_d_arrivee);
GET_ARGUMENT_F("fa=""attenuation=""a=",facteur_d_attenuation);
GET_ARGUMENT_L("editer=",editer_le_facteur_d_attenuation);
GET_ARGUMENT_F("fA=",facteur_A);
GET_ARGUMENT_F("fB=",facteur_B);
GET_ARGUMENT_L("normaliser=",normaliser_le_cumul);
GET_ARGUMENT_L("logarithmique=""log=",prendre_une_dynamique_logarithmique);
GET_ARGUMENT_L("maximum=",rechercher_le_maximum);
/* Le parametre : */
/* */
/* GET_ARGUMENT_L("m=",rechercher_le_maximum); */
/* */
/* a ete supprime le 20031004162701 par symetrie avec 'en_fait_rechercher_le_minimum' pour */
/* lequel un "abrege" n'existe pas... */
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("rn=""renormaliser=""r=",les_images_standards_sont_a_renormaliser);
GET_ARGUMENT_L("translation_quelconque=""translation=""quelconque=",translation_quelconque);
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 20050623144553, "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, puis a la fin le */
/* resultat renormalise par le nombre d'images... */
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... */
Test(IZEQ(facteur_d_attenuation))
Bblock
Test(IL_FAUT(faire_varier_lineairement_le_facteur_d_attenuation))
Bblock
PRINT_ATTENTION("le facteur d'attenuation va varier lineairement, il n'est donc pas ajuste automatiquement");
Eblock
ATes
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 */
/* */
/* Voir a ce propos 'v $xtc/facteur.01$c'. */
Test(IL_FAUT(editer_le_facteur_d_attenuation))
Bblock
CAL3(Prme1("facteur d'attenuation effectif : %.^^^\n",facteur_d_attenuation));
/* Le 20060105154522, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123148, le format "^^g" est passe a "^^^" pour plus de souplesse... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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)
)
,COND(EST_VRAI(les_images_sont_standards)
,FLOT__BLANC
,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
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 20221212114038, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA1,IFmageA1,nom_image))))
Bblock
/* 'ImageA1' donne la couche a l'instant courant, */
CALS(gInettoyage(les_images_sont_standards,ImageA2,IFmageA2));
/* On ne sait jamais... */
Test(IL_FAUT(faire_une_complementation))
Bblock
CALS(gIcomplementation(les_images_sont_standards,ImageA2,IFmageA2,ImageA1,IFmageA1));
CALS(gImove(les_images_sont_standards,ImageA1,IFmageA1,ImageA2,IFmageA2));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_une_symetrie_OX))
Bblock
CALS(gIx_symetrie(les_images_sont_standards,ImageA2,IFmageA2,ImageA1,IFmageA1));
CALS(gImove(les_images_sont_standards,ImageA1,IFmageA1,ImageA2,IFmageA2));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_une_symetrie_OY))
Bblock
CALS(gIy_symetrie(les_images_sont_standards,ImageA2,IFmageA2,ImageA1,IFmageA1));
CALS(gImove(les_images_sont_standards,ImageA1,IFmageA1,ImageA2,IFmageA2));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_varier_lineairement_le_facteur_d_attenuation))
Bblock
EGAL(facteur_d_attenuation_courant
,BARY(facteur_d_attenuation_de_depart
,facteur_d_attenuation_d_arrivee
,DIVI(FLOT(NBRE(premiere_image,numero_d_image)),FLOT(NBRE(premiere_image,derniere_image)))
)
);
/* Facteur d'attenuation de la couche courante qui est proportionnel au numero courant... */
Eblock
ATes
Bblock
EGAL(facteur_d_attenuation_courant
,PUIX(facteur_d_attenuation
,ATTENUATION(facteur_A
,SOUS(derniere_image,numero_d_image)
,facteur_B
)
)
);
/* Facteur d'attenuation de la couche courante qui vaut 'facteur_d_attenuation' eleve a */
/* une puissance qui est le rang de cette couche (voir a ce propos 'v $xtc/facteur.01$c'). */
Eblock
ETes
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas d'une image 'image' : */
CALi(Inoir(ImageA2));
/* Nettoyage systematique de 'ImageA2' a cause du fait que la translation peut etre non */
/* nulle (on risque alors de recuperer des morceaux du contenu anterieur de 'ImageA2'). */
Test(IFET(IL_NE_FAUT_PAS(translation_quelconque),IZEQ(facteur_stereoscopique)))
Bblock
CALS(Itranslation(ImageA2
,ImageA1
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on decale l'image courante... */
Eblock
ATes
Bblock
CALS(Irotation_image(ImageA2
,ImageA1
,VRAI
,ADRESSE(RRtranslation),ADRESSE(RAtranslation),ADRESSE(Atranslation)
,FZERO
,VRAI
)
);
/* Et on decale l'image courante. ATTENTION, rappelons que 'Irotation_image(...)' fait */
/* appel a 'Ifloat_std(...)' ce qui peut creer des messages d'erreur lorsqu'une image que */
/* l'on va accumuler est 'NOIR' ; en effet, on trouve alors : */
/* */
/* ATTENTION : Ifloat_std : les niveaux 'minimal' et 'maximal' sont egaux... */
/* */
/* qui n'a rien a voir avec les appels suivants a 'Ifloat_std(...)'... */
Eblock
ETes
CALS(Istd_float(couche_courante
,FLOT__NOIR
,MUL2(facteur_d_attenuation_courant
,FLOT__BLANC
)
,ImageA2
)
);
/* Conversion flottante avec attenuation eventuelle... */
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
CALi(IFinitialisation(IFmageA2,FZERO));
/* Nettoyage systematique de 'IFmageA2' a cause du fait que la translation peut etre non */
/* nulle (on risque alors de recuperer des morceaux du contenu anterieur de 'IFmageA2'). */
Test(IL_NE_FAUT_PAS(translation_quelconque))
Bblock
CALS(IFtranslation(IFmageA2
,IFmageA1
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on decale l'image courante... */
Eblock
ATes
Bblock
PRINT_ATTENTION("la translation quelconque n'est pas implementee pour les 'imageF'");
CALS(IFtranslation(IFmageA2
,IFmageA1
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on decale l'image courante... */
Eblock
ETes
CALS(IFscale(couche_courante
,facteur_d_attenuation_courant
,IFmageA2
,FZERO
)
);
/* Attenuation eventuelle de la couche courante... */
Eblock
ETes
/* ATTENTION, jusqu'au 19970930085718, que les images soient "standard" ou pas, ou bien */
/* c'etait le maximum qui etait recherche, ou bien c'etait une somme qui etait effectuee... */
/* Par contre, a partir du 19970930085718, ce n'est plus le cas ; d'une part, une troisieme */
/* operation a ete introduite (le produit), et d'autre part, en ce qui concerne les */
/* images "standard", une seule operation parmi les trois peut etre effectuee, alors que */
/* pour les images "non standard", les trois operations peuvent se cumuler les unes apres */
/* les autres (dans l'ordre : maximum, somme et produit). */
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas d'une image 'image' : */
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
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
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
PRINT_ATTENTION("aucune operation de cumul n'a ete selectionnee");
Eblock
ETes
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
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
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. */
INCR(attenuation_globale,facteur_d_attenuation_courant);
/* Cumul des coefficients d'attenuation courants... */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_image);
Eblock
EDoI
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas d'une image 'image' : */
Test(IL_FAUT(rechercher_le_maximum))
Bblock
CALS(Ifloat_std(ImageR,cumul_des_couches,FLOT__NOIR,FLOT__BLANC));
/* Enfin, on convertit en une image standard sans renormalisation puisque theoriquement */
/* la dynamique des images Arguments n'a pas change par la recherche du maximum... */
Eblock
ATes
Bblock
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 automatique, et ce de */
/* facon a conserver la dynamique des images Arguments... */
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
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(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... */
Eblock
ATes
Bblock
CALS(IFmove(IFmageR
,cumul_des_couches
)
);
/* Pas de renormalisation... */
Eblock
ETes
Eblock
ETes
CALi(gIupdate_image(les_images_sont_standards,nom_imageR,ImageR,IFmageR));
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