/*************************************************************************************************************************************/
/* */
/* 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 " M A S Q U A G E " A V E C " A N T I - A L I A S I N G " : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande "accumule" une serie d'images */
/* en effectuant l'operation suivante ('i' designant */
/* un indice de parcours de la liste 'Image') : */
/* */
/* Cumul <-- Cumul masquant Image(i) en depth-cueing (binarise ou pas) */
/* */
/* avec implicitement un parcours d'arriere en avant (c'est-a-dire */
/* que la premiere image recuperee est mise en arriere-plan). */
/* */
/* */
/* Note sur l'eclairage : */
/* */
/* Pour generer un objet eclaire (ou du moins pour */
/* simuler l'eclairage), il suffira de transformer au */
/* prealable toutes les images a accumuler par l'une */
/* des deux commandes suivantes : */
/* */
/* $xci/solarise.11$Z */
/* $xci/solarise.12$Z */
/* */
/* sachant que la seconde est plus "souple" car elle */
/* permet de reorienter la source lumineuse grace a ces */
/* deux parametres 'horizontal' et 'vertical' utilises */
/* pour le calcul de la derivee du champ... */
/* */
/* */
/* 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 */
/* */
/* ou plus simple : */
/* */
/* $DROITE : translation_quelconque=VRAI stereo=+0.5 */
/* $GAUCHE : translation_quelconque=VRAI stereo=-0.5 */
/* */
/* 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. On notera enfin que la translation */
/* implicite 'trx' vaut : */
/* */
/* 1 -4 -4 */
/* ----- = 9.765625 x 10 ~ 10 x 10 */
/* 512 */
/* */
/* la translation 'trx' utilisee est donc choisie egale a la moitie de */
/* cette valeur (d'ou le "5.0e-4"). Pour plus de 128 images, il faudra */
/* reduire 'trx', et pour moins de 128 images, il faudra l'augmenter. */
/* */
/* */
/* Author of '$xci/accumule.12$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_QUAD_IMAGE_EXT
#include image_image_PENT_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. */ \
/* */
#define COMPLEMENTER_LE_MASQUE \
FAUX \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') complementer le masque. */
#define SEUIL_DE_MASQUAGE \
GRIS \
/* Seuil de masquage. */
#define BINARISER_LES_IMAGES \
VRAI \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') binariser les images. */
#define PREMIERE_TRANCHE_VERTICALE \
Zmin \
/* Premiere tranche verticale, */
#define DERNIERE_TRANCHE_VERTICALE \
Zmax \
/* Derniere tranche verticale. */
#include xci/accumule.01.I"
#define PAS_HORIZONTAL \
_____lNORMALISE_OX(I_lHOMOTHETIE_Std_OX(PasX))
#define PAS_VERTICAL \
_____lNORMALISE_OY(I_lHOMOTHETIE_Std_OY(PasY))
/* Pas de decalage des differentes images... */
/* */
/* Le 20120212094445, les 'I_lHOMOTHETIE_Std_O?(...)'s furent introduits... */
#define LE_NOYAU_DE_CONVOLUTION_EST_CARRE \
VRAI \
/* Indique si le noyau de convolution est carre ('VRAI') ou circulaire ('FAUX'). */
#define NOMBRE_DE_POINTS_DU_NOYAU \
EXP2(DOUP(UN)) \
/* Nombre de points du noyau. */
#define VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION \
FU \
/* Facteur implicite des elements du noyau de convolution. */
#define FACTEUR_MULTIPLICATIF_DE_CONVOLUTION \
FU \
/* Facteur multiplicatif du produit de convolution en chaque point {X,Y}. */
#define IL_FAUT_RENORMALISER \
FAUX \
/* Faut-il renormaliser l'image ? */
#define IL_FAUT_UN_LISERE \
FAUX \
/* Faut-il un lisere delimitant chaque couche ('VRAI') ou pas ('FAUX'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#include xci/convol.01.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 " M A S Q U A G E " A V E C " A N T I - A L I A S I N G " : */
/* */
/*************************************************************************************************************************************/
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(Int,INIT(premiere_image,PREMIERE_IMAGE));
/* Numero de la premiere image, */
DEFV(Int,INIT(derniere_image,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(Int,INIT(numero_d_image,UNDEF));
/* Numero de l'image courante. */
DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Logical,INIT(complementer_le_masque,COMPLEMENTER_LE_MASQUE));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') complementer le masque. */
DEFV(genere_p,INIT(seuil_de_masquage,SEUIL_DE_MASQUAGE));
/* Seuil de masquage. */
DEFV(Logical,INIT(binariser_les_images,BINARISER_LES_IMAGES));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') binariser les images. */
DEFV(Int,INIT(premiere_tranche_verticale,PREMIERE_TRANCHE_VERTICALE));
/* Premiere tranche verticale, */
DEFV(Int,INIT(derniere_tranche_verticale,DERNIERE_TRANCHE_VERTICALE));
/* Derniere tranche verticale. */
DEFV(Int,INIT(tranche_verticale_courante,UNDEF));
/* Tranche verticale courante. */
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... */
/* */
/* ATTENTION, ce parametre est ignore des que 'facteur_stereoscopique' est non nul... */
DEFV(Logical,INIT(faire_une_complementation,FAIRE_UNE_COMPLEMENTATION));
/* Faut-il faire une complementation ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit le */
/* 20030317144042. */
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) */
/* */
DEFV(Int,INIT(coordonnee_z_de_depth_cueing,UNDEF));
/* Coordonnee de "depth-cueing"... */
DEFV(Logical,INIT(le_noyau_de_convolution_est_carre,LE_NOYAU_DE_CONVOLUTION_EST_CARRE));
/* Indique si le noyau de convolution est carre ('VRAI') ou circulaire ('FAUX'). */
DEFV(Logical,DTb1(niveaux_a_traiter,COULEURS));
/* Definit les niveaux sur lesquels on doit faire la convolution par 'Pconvolution()'. */
DEFV(Logical,DTb1(niveaux_cumulables,COULEURS));
/* Definit les niveaux cumulables lors du calcul de 'Pconvolution_____cumul_courant'. */
DEFV(Float,INIT(facteur_multiplicatif,FACTEUR_MULTIPLICATIF_DE_CONVOLUTION));
/* Facteur multiplicatif du produit de convolution en chaque point {X,Y}. */
DEFV(Int,INIT(nombre_de_points,NOMBRE_DE_POINTS_DU_NOYAU));
/* Nombre de points du noyau. */
DEFV(Float,DTb1(noyau,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION));
/* Noyau de la convolution, */
DEFV(Float,INIT(noyau_01,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_02,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_03,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_04,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_05,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_06,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_07,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_08,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_09,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_10,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_11,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_12,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_13,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_14,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_15,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_16,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_17,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_18,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_19,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_20,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_21,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_22,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_23,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_24,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
DEFV(Float,INIT(noyau_25,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION));
/* Definition des 9 premiers elements du noyau (meme si le noyau fait moins de 9 points), */
/* et qui sont redefinissables. A titre d'exemple : */
/* */
/* p=9 n1=0 n2=+1 n3=0 n4=0 n5=0 n6=-1 n7=0 n8=0 n9=0 normaliser=FAUX renormaliser=VRAI */
/* */
/* donne la derivee de 'ImageR' par rapport a 'OX', alors que : */
/* */
/* p=9 n1=0 n2=0 n3=0 n4=+1 n5=0 n6=0 n7=0 n8=-1 n9=0 normaliser=FAUX renormaliser=VRAI */
/* */
/* donne la derivee de 'ImageR' par rapport a 'OY'. */
/* */
/* Le passage de 9 a 25 a ete introduit le 20210308131611... */
DEFV(Logical,DTb1(inhibition_du_noyau,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION));
/* Et sa liste d'activite. */
DEFV(Int,INIT(index,UNDEF));
/* Index d'initialisation du noyau. */
DEFV(Logical,INIT(il_faut_un_lisere,IL_FAUT_UN_LISERE));
/* Faut-il un lisere delimitant chaque couche ('VRAI') ou pas ('FAUX'). */
/*..............................................................................................................................*/
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_I("premiere=",premiere_image);
GET_ARGUMENT_I("derniere=",derniere_image);
GET_ARGUMENT_I("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=""lineaire=",Irotation_image_____interpolation_cubique);
/* Arguments introduits le 20131230125923... */
GET_ARGUMENT_L("Mcomplementer=",complementer_le_masque);
/* Le 20050623143749, "complementer=" a ete remplace par "Mcomplementer=" (double def...). */
GET_ARGUMENT_P("seuil=""masque=",seuil_de_masquage);
GET_ARGUMENT_L("binariser=",binariser_les_images);
GET_ARGUMENT_I("zmin=",premiere_tranche_verticale);
GET_ARGUMENT_I("zmax=",derniere_tranche_verticale);
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 20050623143749, "facteur=" a ete remplace par "Sfacteur=" (double definition...). */
GET_ARGUMENT_L("tore=",Pconvolution_____placer_l_image_sur_un_tore);
GET_ARGUMENT_L("ponderations_utiles="
,Pconvolution_____normaliser_uniquement_avec_les_ponderations_utilisees
);
GET_ARGUMENT_L("noyau_carre=""ncarre=",le_noyau_de_convolution_est_carre);
/* Le 20060118092140, "carre=" a ete remplace par "noyau_carre=" et "ncarre=" (risque de */
/* double definition...). */
GET_ARGUMENT_N("noyau_circulaire=""ncirculaire=",le_noyau_de_convolution_est_carre);
/* Ces deux parametres furent introduits le 20071003113647... */
GET_ARGUMENT_F("facteur=""f=",facteur_multiplicatif);
GET_ARGUMENT_I("pmX=",Pconvolution_____pasX_de_la_mosaique_de_convolution);
GET_ARGUMENT_I("pmY=",Pconvolution_____pasY_de_la_mosaique_de_convolution);
GET_ARGUMENT_I("tmX=",Pconvolution_____translationX_de_la_mosaique_de_convolution);
GET_ARGUMENT_I("tmY=",Pconvolution_____translationY_de_la_mosaique_de_convolution);
GET_ARGUMENT_I("saut=",Pconvolution_____nombre_de_points_sautes);
GET_ARGUMENT_L("normaliser=",Pconvolution_____normaliser_le_cumul_pondere);
GET_ARGUMENT_F("transfert=",Pconvolution_____exposant_de_la_fonction_de_transfert);
GET_ARGUMENT_I("points=""p=",nombre_de_points);
GET_ARGUMENT_F("n1=",noyau_01);
GET_ARGUMENT_F("n2=",noyau_02);
GET_ARGUMENT_F("n3=",noyau_03);
GET_ARGUMENT_F("n4=",noyau_04);
GET_ARGUMENT_F("n5=",noyau_05);
GET_ARGUMENT_F("n6=",noyau_06);
GET_ARGUMENT_F("n7=",noyau_07);
GET_ARGUMENT_F("n8=",noyau_08);
GET_ARGUMENT_F("n9=",noyau_09);
GET_ARGUMENT_F("n10=",noyau_10);
GET_ARGUMENT_F("n11=",noyau_11);
GET_ARGUMENT_F("n12=",noyau_12);
GET_ARGUMENT_F("n13=",noyau_13);
GET_ARGUMENT_F("n14=",noyau_14);
GET_ARGUMENT_F("n15=",noyau_15);
GET_ARGUMENT_F("n16=",noyau_16);
GET_ARGUMENT_F("n17=",noyau_17);
GET_ARGUMENT_F("n18=",noyau_18);
GET_ARGUMENT_F("n19=",noyau_19);
GET_ARGUMENT_F("n20=",noyau_20);
GET_ARGUMENT_F("n21=",noyau_21);
GET_ARGUMENT_F("n22=",noyau_22);
GET_ARGUMENT_F("n23=",noyau_23);
GET_ARGUMENT_F("n24=",noyau_24);
GET_ARGUMENT_F("n25=",noyau_25);
/* Le passage de 9 a 25 a ete introduit le 20210308131611... */
/* */
/* Disposition des 25 premiers points du noyau sur la spirale : */
/* */
/* */
/* 17---16---15---14---13 */
/* | | */
/* | | */
/* 18 5----4----3 12 */
/* | | | | */
/* | | | | */
/* 19 6 1----2 11 */
/* | | | */
/* | | | */
/* 20 7----8----9---10 */
/* | */
/* | */
/* 21---22---23---24---25 */
/* */
GET_ARGUMENT_L("editer_noyau_convolution=""enc=",Pconvolution_____editer_le_noyau_de_convolution);
GET_ARGUMENT_I("Xedition_noyau_convolution=""Xenc="
,Pconvolution_____coordonnee_X_d_edition_du_noyau_de_convolution
);
GET_ARGUMENT_I("Yedition_noyau_convolution=""Yenc="
,Pconvolution_____coordonnee_Y_d_edition_du_noyau_de_convolution
);
/* Possibilite introduite le 20210309110536... */
GET_ARGUMENT_I("spirale_horizontal=",SPIRALE_DEFINITION_____facteur_delta_horizontal);
GET_ARGUMENT_I("spirale_vertical=",SPIRALE_DEFINITION_____facteur_delta_vertical);
GET_ARGUMENT_L("lisere=",il_faut_un_lisere);
)
);
Test(EST_VRAI(il_faut_un_lisere))
Bblock
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
EGAL(ITb1(niveaux_a_traiter,INDX(niveau,NOIR)),FAUX);
Eblock
EBoI
EGAL(ITb1(niveaux_a_traiter,INDX(NOIR,NOIR)),VRAI);
/* Initialisation telle que seul le NOIR soit "traitable"... */
Eblock
ATes
Bblock
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
EGAL(ITb1(niveaux_a_traiter,INDX(niveau,NOIR)),VRAI);
Eblock
EBoI
EGAL(ITb1(niveaux_a_traiter,INDX(NOIR,NOIR)),FAUX);
/* Initialisation telle que seul le NOIR ne soit pas "traitable"... */
Eblock
ETes
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
EGAL(ITb1(niveaux_cumulables,INDX(niveau,NOIR)),VRAI);
/* Initialisation telle que tous les niveaux soient "cumulables". */
Eblock
EBoI
Test(IFLE(nombre_de_points,TAILLE_MAXIMALE_D_UN_NOYAU_DE_CONVOLUTION))
Bblock
DoIn(index,PREMIER_POINT,LSTX(PREMIER_POINT,nombre_de_points),I)
Bblock
NOYAU(index,VALEUR_INITIALE_DU_NOYAU_DE_CONVOLUTION);
/* Initialisation du noyau de convolution. */
Eblock
EDoI
Eblock
ATes
Bblock
PRINT_ERREUR("la taille demandee pour le noyau de convolution est incompatible avec les definitions");
EGAL(nombre_de_points,NOMBRE_DE_POINTS_DU_NOYAU);
CAL1(Prer1("(la valeur %d par defaut est forcee)\n",nombre_de_points));
/* Introduit le 20111031140704 car, en effet, manquait cruellement... */
Eblock
ETes
NOYAU(ADD2(PREMIER_POINT,ZERO),noyau_01);
NOYAU(ADD2(PREMIER_POINT,UN),noyau_02);
NOYAU(ADD2(PREMIER_POINT,DEUX),noyau_03);
NOYAU(ADD2(PREMIER_POINT,TROIS),noyau_04);
NOYAU(ADD2(PREMIER_POINT,QUATRE),noyau_05);
NOYAU(ADD2(PREMIER_POINT,CINQ),noyau_06);
NOYAU(ADD2(PREMIER_POINT,SIX),noyau_07);
NOYAU(ADD2(PREMIER_POINT,SEPT),noyau_08);
NOYAU(ADD2(PREMIER_POINT,HUIT),noyau_09);
NOYAU(ADD2(PREMIER_POINT,NEUF),noyau_10);
NOYAU(ADD2(PREMIER_POINT,DIX),noyau_11);
NOYAU(ADD2(PREMIER_POINT,ONZE),noyau_12);
NOYAU(ADD2(PREMIER_POINT,DOUZE),noyau_13);
NOYAU(ADD2(PREMIER_POINT,TREIZE),noyau_14);
NOYAU(ADD2(PREMIER_POINT,QUATORZE),noyau_15);
NOYAU(ADD2(PREMIER_POINT,QUINZE),noyau_16);
NOYAU(ADD2(PREMIER_POINT,SEIZE),noyau_17);
NOYAU(ADD2(PREMIER_POINT,DIX_SEPT),noyau_18);
NOYAU(ADD2(PREMIER_POINT,DIX_HUIT),noyau_19);
NOYAU(ADD2(PREMIER_POINT,DIX_NEUF),noyau_20);
NOYAU(ADD2(PREMIER_POINT,VINGT),noyau_21);
NOYAU(ADD2(PREMIER_POINT,VINGT_ET_UN),noyau_22);
NOYAU(ADD2(PREMIER_POINT,VINGT_DEUX),noyau_23);
NOYAU(ADD2(PREMIER_POINT,VINGT_TROIS),noyau_24);
NOYAU(ADD2(PREMIER_POINT,VINGT_QUATRE),noyau_25);
/* Initialisation des 9 premiers elements du noyau de convolution (meme si la taille */
/* demandee est inferieure a 9) avec des valeurs eventuellement arguments d'appel... */
/* On notera que l'on ecrase ainsi une partie de l'initialisation faite ci-dessus dans la */
/* boucle 'DoIn(...)' que l'on ne modifie pas pour simplifier... */
/* */
/* Le passage de 9 a 25 a ete introduit le 20210308131611... */
INITIALISATION_ACCROISSEMENT_2D(Atranslation
,FZERO
,FZERO
);
INITIALISATION_ACCROISSEMENT_2D(RAtranslation
,FZERO
,FZERO
);
INITIALISATION_ACCROISSEMENT_2D(RRtranslation
,NEUT(MUL2(VRAI_PAS_HORIZONTAL,MOIT(FLOT(LENG(premiere_image,derniere_image)))))
,NEUT(MUL2(VRAI_PAS_VERTICAL,MOIT(FLOT(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(Inoir(ImageR));
/* Initialisation de l'image Resultat. */
EGAL(tranche_verticale_courante,premiere_tranche_verticale);
/* Initialisation de la tranche verticale courante. */
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
EGAL(nom_image
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres)
)
,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres)
,nom_postfixe
)
)
);
/* Le 20221212114718, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA5,nom_image))))
Bblock
/* 'ImageA5' donne la couche a l'instant courant. */
CALi(Inoir(ImageA6));
/* On ne sait jamais... */
Test(IL_FAUT(faire_une_complementation))
Bblock
CALS(Icomplementation(ImageA6,ImageA5));
CALS(Imove(ImageA5,ImageA6));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_une_symetrie_OX))
Bblock
CALS(Ix_symetrie(ImageA6,ImageA5));
CALS(Imove(ImageA5,ImageA6));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_une_symetrie_OY))
Bblock
CALS(Iy_symetrie(ImageA6,ImageA5));
CALS(Imove(ImageA5,ImageA6));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(complementer_le_masque))
Bblock
CALS(Icomplementation(Masque,ImageA5));
/* Lorsque le masque est a complementer, il est identique a la couche courante inversee... */
Eblock
ATes
Bblock
CALS(Imove(Masque,ImageA5));
/* Lorsque le masque n'est pas a complementer, il est identique a la couche courante... */
Eblock
ETes
CALi(Inoir(ImageA1));
/* Initialisation de l'image intermediaire. */
EGAL(coordonnee_z_de_depth_cueing
,NIVA(__DENORMALISE_NIVEAU(_____lNORMALISE_OZ(COZR(tranche_verticale_courante))))
);
/* Afin de faire du "depth-cueing", la troisieme coordonnee 'z' suit les couleurs... */
MASQUE_IMAGES(seuil_de_masquage);
/* Activation du masquage des images. */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
Test(IL_FAUT(binariser_les_images))
Bblock
MODIFICATION_LISTE_DE_SUBSTITUTION(niveau,GENP(coordonnee_z_de_depth_cueing));
/* La liste de substitution (associee au masque) est telle que tout ce qui */
/* est inferieur au seuil disparait, et que les autres sont materialises */
/* par le 'z' de depth-cueing... */
Eblock
ATes
Bblock
MODIFICATION_LISTE_DE_SUBSTITUTION(niveau
,MAX2(GENP(NIVA(SCAL(NIVR(niveau)
,NIVR(BLANC)
,NIVR(coordonnee_z_de_depth_cueing)
)
)
)
,NOIR_PLANCHER
)
);
/* La liste de substitution (associee au masque) est telle que tout ce qui */
/* est inferieur au seuil disparait, et que les autres sont materialises */
/* par une echelle allant de 'NOIR_PLANCHER' au 'z' de depth-cueing... */
Eblock
ETes
Eblock
EBoI
Test(IFET(IL_NE_FAUT_PAS(translation_quelconque),IZEQ(facteur_stereoscopique)))
Bblock
SUBSTITUTION(L_SUBSTITUTION_VARIABLE);
SET_FILTRAGE(ACTIF);
/* Activation du filtrage de "depth-cueing". */
CALS(Itranslation(ImageA1
,ImageA5
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on superpose les images... */
SET_FILTRAGE(INACTIF);
/* Inhibition du filtrage... */
Eblock
ATes
Bblock
SUBSTITUTION(L_SUBSTITUTION_VARIABLE);
SET_FILTRAGE(ACTIF);
/* Activation du filtrage de "depth-cueing". */
DEMASQUE_IMAGES;
CALS(Imove(ImageA4,ImageA5));
MASQUE_IMAGES(seuil_de_masquage);
/* Filtrage de "depth-cueing" ; on notera qu'il est fait sur toute l'image afin d'eviter des */
/* problemes d'interpolation dans 'Irotation_image(...)' (en effet, les points "frontiere" */
/* ont une partie de leur voisin hors du masque, et ils sont utilises malgre tout lors de */
/* l'interpolation...). */
SET_FILTRAGE(INACTIF);
/* Inhibition du filtrage... */
CALS(Irotation_image(ImageA1
,ImageA4
,FAUX
,ADRESSE(RRtranslation),ADRESSE(RAtranslation),ADRESSE(Atranslation)
,FZERO
,VRAI
)
);
/* Et on superpose les images (sans reinitialiser 'ImageA1' a chaque iteration...). */
Eblock
ETes
DEMASQUE_IMAGES;
/* Inhibition du masquage... */
CALS(Ibinarisation_generale(ImageA2,ImageA1,NOIR,NOIR,BLANC));
/* Creation d'un masque binaire a partir de la couche courante, */
CALS(Iconvolution_avec_renormalisation(ImageA3
,facteur_multiplicatif
,ImageA2
,niveaux_a_traiter,niveaux_cumulables
,nombre_de_points,noyau,inhibition_du_noyau
,les_images_standards_sont_a_renormaliser
)
);
/* Et convolution de ce masque binaire ce qui donne le ponderateur de la couche courante. */
CALS(Icomplementation(ImageA2,ImageA3));
/* Puis generation du ponderateur du cumul courant (complementaire du premier). */
CALS(Iinterpolation_quelconque(ImageR,ImageA3,ImageA1,ImageA2,ImageR));
/* Et interpolation a l'aide des deux ponderateurs 'ImageA3' et 'ImageA2' */
/* entre les couche courante 'ImageA1' et le cumul courant 'ImageR'... */
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(tranche_verticale_courante
,DIVZ(SOUS(derniere_tranche_verticale,premiere_tranche_verticale)
,DIVZ(SOUS(derniere_image,premiere_image)
,pas_des_images
)
)
);
/* Mise a jour de la tranche verticale courante. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_image);
Eblock
EDoI
CALi(Iupdate_image(nom_imageR,ImageR));
RETU_Commande;
Eblock
ECommande