/*************************************************************************************************************************************/
/* */
/* 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 " : */
/* */
/* */
/* 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 et la */
/* derniere au premier-plan), cet ordre pouvant etre inverse, soit : */
/* */
/* inverser=FAUX (par defaut) : */
/* */
/* */
/* --------------------------------------- */
/* |image 1 | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* --------------------------------------- | */
/* |image N-2 | | */
/* | | | */
/* | | | */
/* | | | */
/* --------------------------------------- | | */
/* |image N-1 | |--------- */
/* | | | */
/* | | | . */
/* | | | */
/* --------------------------------------- | | . */
/* |image N | | | */
/* | | | | . */
/* | | | | */
/* | | | | . */
/* | | | | */
/* | | |---- */
/* | | | */
/* | |---- */
/* | | */
/* | | */
/* | | */
/* | | */
/* --------------------------------------- */
/* */
/* */
/* inverser=VRAI : */
/* */
/* */
/* --------------------------------------- */
/* |image N | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* . | . | */
/* | | */
/* --------------------------------------- | */
/* |image 3 | | */
/* | | | */
/* | | | */
/* | | | */
/* --------------------------------------- | | */
/* |image 2 | |--------- */
/* | | | */
/* | | | . */
/* | | | */
/* --------------------------------------- | | . */
/* |image 1 | | | */
/* | | | | . */
/* | | | | */
/* | | | | . */
/* | | | | */
/* | | |---- */
/* | | | */
/* | |---- */
/* | | */
/* | | */
/* | | */
/* | | */
/* --------------------------------------- */
/* */
/* */
/* 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.02$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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 GERER_LA_TRANSPARENCE \
FAUX \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') faire de la transparence au */ \
/* prealable ; celle-ci est faite dans les parties exterieures a 'MASQUE_IMAGES(...)' */ \
/* (c'est-a-dire dans les parties "masquees") de la meme facon que cela est fait dans */ \
/* 'v $xci/accumule.01$K'). */
#include xci/accumule.03.I"
#define FAIRE_UN_FILTRAGE_PASSE_BANDE \
FAUX \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') faire un filtrage "passe-bande" */ \
/* de l'image ce qui permet alors d'extraire des "iso-surfaces"... */
#define FORCER_LE_NOIR \
VRAI \
/* Cet indicateur precise la methode de visualisation de ce qui est exclu : */ \
/* */ \
/* VRAI : on utilise respectivement 'NIVEAU_PASSE_BANDE_INFERIEUR' et */ \
/* 'NIVEAU_PASSE_BANDE_SUPERIEUR', */ \
/* FAUX : on utilise respectivement 'PRED(seuil_inferieur)' et */ \
/* 'SUCC(seuil_superieur)'. */ \
/* */ \
/* dans le cas d'un filtrage "passe-bande". */
#define SEUIL_INFERIEUR \
SUCC(SUCC(NOIR)) \
/* Seuil inferieur du filtre "passe-bande", */
#define SEUIL_SUPERIEUR \
PRED(PRED(BLANC)) \
/* Seuil superieur du filtre "passe-bande", */
#define COMPLEMENTER_LE_MASQUE \
FAUX \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') complementer le masque. */
#define INTERPOLER_LE_SEUIL_DE_MASQUAGE \
FAUX
#define SEUIL_DE_MASQUAGE_DE_DEPART \
NOIR
#define SEUIL_DE_MASQUAGE_D_ARRIVEE \
BLANC
/* Faut-il interpoler le seuil de masquage ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit */
/* le 20020308145352. */
#define CALCULER_LE_SEUIL_DE_MASQUAGE \
FAUX \
/* Faut-il calculer automatiquement ('VRAI') le seuil de masquage a l'aide de l'histogramme */ \
/* "cumule" ou bien le fixer a priori ('FAUX'). Ceci n'a de sens que dans le cas ou */ \
/* 'IL_NE_FAUT_PAS(interpoler_le_seuil_de_masquage)'... */
#define FRACTION_DE_POINTS_POUR_CALCULER_LE_SEUIL_DE_MASQUAGE \
FRA10(FU) \
/* Lorsqu'il faut calculer le seuil de masquage ce parametre donne le pourcentage des */ \
/* points a prendre en compte pour le masque. */
#define SEUIL_DE_MASQUAGE \
GRIS \
/* Seuil de masquage. */
#define COMPATIBILITE_20091128 \
FAUX \
/* Permet d'assurer la compatibilite anterieure au 20091128095646 si besoin est... */
#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 20120212093853, les 'I_lHOMOTHETIE_Std_O?(...)'s furent introduits... */
#define MEMORISER_LE_Z_BUFFER \
FAUX \
/* Indique si le 'Z-Buffer' doit etre fourni comme resultat ('VRAI'), ou bien oublie */ \
/* apres le calcul ('FAUX'). On notera que la sortie du 'Z-Buffer' peut etre redondante */ \
/* d'avec celle de l'accumulation proprement dite, mais que cela n'est plus vrai des que */ \
/* 'IL_NE_FAUT_PAS(binariser_les_images)'. */
#define MEMORISER_LE_Z_BUFFER_COMME_UNE_IMAGE_STANDARD \
VRAI \
/* Indique si le 'Z-Buffer' est fourni comme resultat, si ce dernier doit etre fourni en */ \
/* tant qu'image standard ('VRAI') ou pas ('FAUX'). */
#define PRENDRE_LA_PARTIE_ENTIERE_DES_COORDONNEES \
FAUX \
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') prendre la partie entiere de la */ \
/* variable 'tranche_verticale_courante'. Cette option, lorsqu'elle est 'VRAI' assure la */ \
/* compatibilite avec les executions anterieures au 1996052200 ; le 1996052300 elle a ete */ \
/* mise a l'etat 'FAUX' par defaut, puisque c'est le mode qui donne les meilleurs resultats. */ \
/* On verra a ce propos les sequences : */ \
/* */ \
/* xivPdf 6 2 / 023628_023755 */ \
/* */ \
/* et : */ \
/* */ \
/* xivPdf 6 2 / 023884_024011 */ \
/* */ \
/* qui illustrent parfaitement le probleme... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#include xci/accumule.04.I"
#define NOM_DE_L_IMAGE_COURANTE(nom_de_la_racine,nombre_de_chiffres,nom_postfixe) \
Bblock \
EGAL(nom_image \
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE) \
,chain_Aconcaten2_sauf_nom_pipe(nom_de_la_racine \
,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres) \
) \
,chain_Aconcaten3_sauf_nom_pipe(nom_de_la_racine \
,chain_numero_modulo(NUMERO_D_IMAGE,nombre_de_chiffres) \
,nom_postfixe \
) \
) \
); \
/* Le 20221212114236, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */ \
Eblock \
/* Generation de 'nom_image'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 " : */
/* */
/*************************************************************************************************************************************/
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_pour_nom_imageA),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_imageA><numero> (par exemple '$ROUGE'). */
DEFV(Int,INIT(nombre_de_chiffres_pour_nom_imageA,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(CHAR,INIC(POINTERc(nom_imageC),NOM_PIPE));
/* Nom de l'eventuel cache de chaque image (introduit le 20030515142626). */
DEFV(CHAR,INIC(POINTERc(nom_postfixe_pour_nom_imageC),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_imageC><numero> (par exemple '$ROUGE'). */
/* Ceci a ete introduit le 20030526104937... */
DEFV(Int,INIT(nombre_de_chiffres_pour_nom_imageC,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie (introduit le 20030526104937). */
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom du Resultat de l'integration. */
DEFV(CHAR,INIC(POINTERc(nom_imageZ),NOM_PIPE));
/* Nom de l'eventuel 'Z-Buffer'. */
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(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(gerer_la_transparence,GERER_LA_TRANSPARENCE));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') faire de la transparence au */
/* prealable ; celle-ci est faite dans les parties exterieures a 'MASQUE_IMAGES(...)' */
/* (c'est-a-dire dans les parties "masquees") de la meme facon que cela est fait dans */
/* 'v $xci/accumule.01$K'). */
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(Logical,INIT(rechercher_le_maximum,RECHERCHE_DU_MAXIMUM));
/* Faut-il rechercher le maximum ('VRAI') ou proceder par cumul arithmetique ('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(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(Logical,INIT(faire_un_filtrage_passe_bande,FAIRE_UN_FILTRAGE_PASSE_BANDE));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') faire un filtrage "passe-bande" */
/* de l'image ce qui permet alors d'extraire des "iso-surfaces"... */
DEFV(Logical,INIT(forcer_le_NOIR,FORCER_LE_NOIR));
/* Cet indicateur precise la methode de visualisation de ce qui est exclu : */
/* */
/* VRAI : on utilise respectivement 'NIVEAU_PASSE_BANDE_INFERIEUR' et */
/* 'NIVEAU_PASSE_BANDE_SUPERIEUR', */
/* FAUX : on utilise respectivement 'PRED(seuil_inferieur)' et */
/* 'SUCC(seuil_superieur)'. */
/* */
/* dans le cas d'un filtrage "passe-bande". */
DEFV(genere_p,INIT(seuil_inferieur,SEUIL_INFERIEUR));
/* Seuil inferieur du filtre "passe-bande", */
DEFV(genere_p,INIT(seuil_superieur,SEUIL_SUPERIEUR));
/* Seuil superieur du filtre "passe-bande", */
DEFV(Logical,INIT(complementer_le_masque,COMPLEMENTER_LE_MASQUE));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') complementer le masque. */
DEFV(Logical,INIT(interpoler_le_seuil_de_masquage,INTERPOLER_LE_SEUIL_DE_MASQUAGE));
DEFV(genere_p,INIT(seuil_de_masquage_de_depart,SEUIL_DE_MASQUAGE_DE_DEPART));
DEFV(genere_p,INIT(seuil_de_masquage_d_arrivee,SEUIL_DE_MASQUAGE_D_ARRIVEE));
/* Faut-il interpoler le seuil de masquage ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit */
/* le 20020308145352. */
DEFV(Logical,INIT(calculer_le_seuil_de_masquage,CALCULER_LE_SEUIL_DE_MASQUAGE));
/* Faut-il calculer automatiquement ('VRAI') le seuil de masquage a l'aide de l'histogramme */
/* "cumule" ou bien le fixer a priori ('FAUX'). Ceci n'a de sens que dans le cas ou */
/* 'IL_NE_FAUT_PAS(interpoler_le_seuil_de_masquage)'... */
DEFV(Float,INIT(fraction_de_points_pour_calculer_le_seuil_de_masquage
,FRACTION_DE_POINTS_POUR_CALCULER_LE_SEUIL_DE_MASQUAGE
)
);
/* Lorsqu'il faut calculer le seuil de masquage ce parametre donne le pourcentage des */
/* points a prendre en compte pour le masque. */
DEFV(genere_p,INIT(seuil_de_masquage,SEUIL_DE_MASQUAGE));
/* Seuil de masquage. */
DEFV(genere_p,INIT(seuil_de_masquage_utilise,NIVEAU_UNDEF));
/* Seuil de masquage reellement utilise. */
DEFV(Logical,INIT(compatibilite_20091128,COMPATIBILITE_20091128));
/* Permet d'assurer la compatibilite anterieure au 20091128095646 si besoin est... */
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(Float,INIT(tranche_verticale_courante,FLOT__UNDEF));
/* Tranche verticale courante, */
DEFV(Float,INIT(pas_des_tranches_verticales,FLOT__UNDEF));
/* Et le pas qui les separe... */
DEFV(Logical,INIT(prendre_la_partie_entiere_des_coordonnees,PRENDRE_LA_PARTIE_ENTIERE_DES_COORDONNEES));
/* Indicateur precisant s'il faut ('VRAI') ou pas ('FAUX') prendre la partie entiere de la */
/* variable 'tranche_verticale_courante'. Cette option, lorsqu'elle est 'VRAI' assure la */
/* compatibilite avec les executions anterieures au 1996052200 ; le 1996052300 elle a ete */
/* mise a l'etat 'FAUX' par defaut, puisque c'est le mode qui donne les meilleurs resultats. */
/* On verra a ce propos les sequences : */
/* */
/* xivPdf 6 2 / 023628_023755 */
/* */
/* et : */
/* */
/* xivPdf 6 2 / 023884_024011 */
/* */
/* qui illustrent parfaitement le probleme... */
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 */
/* 20030317143126. */
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(Logical,INIT(memoriser_le_Z_Buffer,MEMORISER_LE_Z_BUFFER));
/* Indique si le 'Z-Buffer' doit etre fourni comme resultat ('VRAI'), ou bien oublie */
/* apres le calcul ('FAUX'). On notera que la sortie du 'Z-Buffer' peut etre redondante */
/* d'avec celle de l'accumulation proprement dite, mais que cela n'est plus vrai des que */
/* 'IL_NE_FAUT_PAS(binariser_les_images)'. */
DEFV(Logical,INIT(memoriser_le_Z_Buffer_comme_une_image_standard,MEMORISER_LE_Z_BUFFER_COMME_UNE_IMAGE_STANDARD));
/* Indique si le 'Z-Buffer' est fourni comme resultat, si ce dernier doit etre fourni en */
/* tant qu'image standard ('VRAI') ou pas ('FAUX'). */
DEFV(Int,INIT(coordonnee_z_de_depth_cueing,UNDEF));
/* Coordonnee de "depth-cueing"... */
/*..............................................................................................................................*/
#define GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard \
"zbuffer_standard=""zBuffer_standard=""Zbuffer_standard=""ZBuffer_standard=""Z-Buffer_standard=" \
/* Afin de raccourcir une ligne suivante (introduit le 20070223105201)... */
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20091128=",compatibilite_20091128);
GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("postfixeA=""postfixe=",nom_postfixe_pour_nom_imageA);
GET_ARGUMENT_C("imageC=""C=",nom_imageC);
GET_ARGUMENT_C("postfixeC=",nom_postfixe_pour_nom_imageC);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_C("imageZ=""Z=",nom_imageZ);
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("chiffresA=""chiffres=",nombre_de_chiffres_pour_nom_imageA);
GET_ARGUMENT_I("chiffresC=",nombre_de_chiffres_pour_nom_imageC);
GET_ARGUMENT_L("interpolation_cubique=""cubique=",Irotation_image_____interpolation_cubique);
GET_ARGUMENT_N("interpolation_lineaire=""lineaire=",Irotation_image_____interpolation_cubique);
/* Arguments introduits le 20131230125403... */
GET_ARGUMENT_L("transparence=",gerer_la_transparence);
GET_ARGUMENT_F("fa=""attenuation=""a=",facteur_d_attenuation);
GET_ARGUMENT_L("editer=",editer_le_facteur_d_attenuation);
GET_ARGUMENT_L("maximum=""m=",rechercher_le_maximum);
GET_ARGUMENT_L("minimum=",en_fait_rechercher_le_minimum);
GET_ARGUMENT_L("passe_bande=""filtrage=",faire_un_filtrage_passe_bande);
GET_ARGUMENT_L("noir=""n=""NOIR=",forcer_le_NOIR);
GET_ARGUMENT_L("strict_gauche=",Ipasse_bande_____tests_stricts_a_gauche);
GET_ARGUMENT_L("strict_droite=",Ipasse_bande_____tests_stricts_a_droite);
GET_ARGUMENT_P("niveau_inferieur=",Ipasse_bande_____niveau_inferieur);
GET_ARGUMENT_P("niveau_superieur=",Ipasse_bande_____niveau_superieur);
GET_ARGUMENT_P("seuil_inferieur=""inf=",seuil_inferieur);
GET_ARGUMENT_P("sup=""seuil_superieur=",seuil_superieur);
GET_ARGUMENT_L("Mcomplementer=",complementer_le_masque);
/* Le 20050623142816, "complementer=" a ete remplace par "Mcomplementer=" (double def...). */
GET_ARGUMENT_L("interpoler_le_seuil=""interpoler=",interpoler_le_seuil_de_masquage);
GET_ARGUMENT_P("seuil_depart=""depart=",seuil_de_masquage_de_depart);
GET_ARGUMENT_P("seuil_arrivee=""arrivee=",seuil_de_masquage_d_arrivee);
GET_ARGUMENT_L("calculer_le_seuil=""calculer=",calculer_le_seuil_de_masquage);
GET_ARGUMENT_F("fraction=",fraction_de_points_pour_calculer_le_seuil_de_masquage);
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("partie_entiere=",prendre_la_partie_entiere_des_coordonnees);
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 20050623142816, "facteur=" a ete remplace par "Sfacteur=" (double definition...). */
GET_ARGUMENT_F("Z0=",Z_Buffer_____valeur_initiale);
GET_ARGUMENT_L("zbuffer=""zBuffer=""Zbuffer=""ZBuffer=""Z-Buffer=",memoriser_le_Z_Buffer);
GET_ARGUMENT_L(GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard
,memoriser_le_Z_Buffer_comme_une_image_standard
);
)
);
/* ATTENTION, il y avait autrefois : */
/* */
/* GET_ARGUMENT_I("Zmin=",premiere_tranche_verticale); */
/* GET_ARGUMENT_I("Zmax=",derniere_tranche_verticale); */
/* */
/* mais cela rentrait en conflit avec : */
/* */
/* GET_ARGUMENT_I("Zmin=",Zmin); \ */
/* GET_ARGUMENT_I("Zmax=",Zmax); \ */
/* */
/* dans '$xig/fonct$vv$DEF' ; donc, */
/* */
/* "zmin=" */
/* "zmax=" */
/* */
/* et : */
/* */
/* "Zmin=" */
/* "Zmax=" */
/* */
/* ne doivent pas etre confondus... */
#undef GET_ARGUMENT_L_____memoriser_le_Z_Buffer_comme_une_image_standard
Test(IFEXff(fraction_de_points_pour_calculer_le_seuil_de_masquage
,COORDONNEE_BARYCENTRIQUE_MINIMALE
,COORDONNEE_BARYCENTRIQUE_MAXIMALE
)
)
Bblock
PRINT_ATTENTION("la fraction de points pour calculer le seuil de masquage n'est pas dans [0,1]");
Eblock
ATes
Bblock
Eblock
ETes
EGAL(seuil_de_masquage_utilise,seuil_de_masquage);
/* A priori... */
Test(IFET(IL_NE_FAUT_PAS(translation_quelconque),IZEQ(facteur_stereoscopique)))
Bblock
Eblock
ATes
Bblock
Test(IL_FAUT(memoriser_le_Z_Buffer))
Bblock
PRINT_ATTENTION("le 'Z-Buffer' ne va pas etre genere");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
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... */
Test(IFNE_chaine(nom_imageC,NOM_PIPE))
/* La posssibilite de cacher une partie de chaque image a ete introduite le 20030515142626. */
Bblock
CALi(Iblanc(ImageA7));
/* Initialisation a priori du cache (au cas ou en particulier l'image 'nom_imageC' */
/* n'existerait pas...). */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(gerer_la_transparence))
Bblock
Test(IZEQ(facteur_d_attenuation))
Bblock
EGAL(facteur_d_attenuation,PUIX(INVE(FLOT__BLANC),INVZ(FLOT(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 20060105154554, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123155, le format "^^g" est passe a "^^^" pour plus de souplesse... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(rechercher_le_maximum),IL_FAUT(en_fait_rechercher_le_minimum)))
Bblock
CALi(Iblanc(ImageR));
/* Initialisation de l'image Resultat. */
Eblock
ATes
Bblock
CALi(Inoir(ImageR));
/* Initialisation de l'image Resultat. */
Eblock
ETes
EGAL(tranche_verticale_courante
,FLOT(COND(IFGT(derniere_image,premiere_image)
,premiere_tranche_verticale
,derniere_tranche_verticale
)
)
);
/* Initialisation de la tranche verticale courante, */
EGAL(pas_des_tranches_verticales
,DIVZ(FLOT(SOUS(derniere_tranche_verticale,premiere_tranche_verticale))
,FLOT(DIVZ(SOUS(derniere_image,premiere_image)
,pas_des_images
)
)
)
);
EGAL(pas_des_tranches_verticales
,COND(IL_FAUT(prendre_la_partie_entiere_des_coordonnees)
,INTE(pas_des_tranches_verticales)
,NEUT(pas_des_tranches_verticales)
)
);
/* Et de son pas... */
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
NOM_DE_L_IMAGE_COURANTE(nom_imageA,nombre_de_chiffres_pour_nom_imageA,nom_postfixe_pour_nom_imageA);
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA5,nom_image))))
Bblock
/* 'ImageA5' donne la couche a l'instant courant. */
Test(IFNE_chaine(nom_imageC,NOM_PIPE))
/* La posssibilite de cacher une partie de chaque image a ete introduite le 20030515142626, */
/* avec une extension le 20030526104937 en faisant de 'nom_imageC' une eventuelle serie */
/* d'images (suivant la valeur de 'nombre_de_chiffres_pour_nom_imageC'...). */
Bblock
NOM_DE_L_IMAGE_COURANTE(nom_imageC,nombre_de_chiffres_pour_nom_imageC,nom_postfixe_pour_nom_imageC);
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA7,nom_image))))
/* ATTENTION : on notera que si 'nombre_de_chiffres_pour_nom_imageC' est nul, on charge */
/* ainsi de nombreuses fois la meme image, mais je ne veux pas optimiser... */
Bblock
Eblock
ATes
Bblock
/* ATTENTION : on notera que si l'image courante 'nom_image' n'existe pas, alors 'ImageA7' */
/* garde la valeur anterieure (soit 'BLANC' la premiere fois et l'image precedente de la */
/* sequence les fois suivantes...). */
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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(faire_un_filtrage_passe_bande))
Bblock
CALS(Ipasse_bande(ImageA6,ImageA5,seuil_inferieur,seuil_superieur,forcer_le_NOIR));
CALS(Imove(ImageA5,ImageA6));
/* Un filtrage passe-bande permet de generer des "iso-surfaces"... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE_chaine(nom_imageC,NOM_PIPE))
Bblock
CALS(Iand(ImageA6,ImageA5,ImageA7));
CALS(Imove(ImageA5,ImageA6));
/* La posssibilite de cacher une partie de chaque image a ete introduite le 20030515142626. */
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
Test(IL_FAUT(gerer_la_transparence))
Bblock
EGAL(facteur_d_attenuation_courant,facteur_d_attenuation);
/* Facteur d'attenuation de la couche courante qui vaut 'facteur_d_attenuation' eleve a */
/* une puissance qui est le rang de cette couche... */
/* */
/* ATTENTION, sur 'v $xci/accumule.01$K', on trouve ici : */
/* */
/* EGAL(facteur_d_attenuation_courant */
/* ,PUIX(facteur_d_attenuation */
/* ,ATTENUATION(facteur_A */
/* ,SOUS(derniere_image,numero_d_image) */
/* ,facteur_B */
/* ) */
/* ) */
/* ); */
/* */
/* car en effet, le facteur 'facteur_d_attenuation' n'est pas applique de facon iterative */
/* alors qu'ici il l'est (il suffit de voir pour cela ce qui est fait de 'ImageR' ci-apres). */
CALi(Inoir(ImageA6));
/* Nettoyage systematique de 'ImageA6' a cause du fait que la translation peut etre non */
/* nulle (on risque alors de recuperer des morceaux du contenu anterieur de 'ImageA6'). */
Test(IFET(IL_NE_FAUT_PAS(translation_quelconque),IZEQ(facteur_stereoscopique)))
Bblock
CALS(Itranslation(ImageA6
,Masque
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on decale l'image courante... */
Eblock
ATes
Bblock
CALS(Irotation_image(ImageA6
,Masque
,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
Test(IL_FAUT(rechercher_le_maximum))
Bblock
CALS(Iscale(ImageA6
,facteur_d_attenuation_courant
,ImageA6
,FZERO
)
);
/* Attenuation eventuelle de la couche courante... */
Test(IL_NE_FAUT_PAS(en_fait_rechercher_le_minimum))
Bblock
CALS(Imaximum(ImageR,ImageR,ImageA6));
/* Et on cumule d'avant en arriere par recherche du maximum. */
Eblock
ATes
Bblock
CALS(Iminimum(ImageR,ImageR,ImageA6));
/* Et on cumule d'avant en arriere par recherche du minimum. */
Eblock
ETes
Eblock
ATes
Bblock
CALS(Iinterpolation(ImageR
,COMP(facteur_d_attenuation_courant),ImageR
,NEUT(facteur_d_attenuation_courant),ImageA6
)
);
/* Et on cumule d'avant en arriere par addition arithmetique. */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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... */
Test(IL_FAUT(interpoler_le_seuil_de_masquage))
Bblock
EGAL(seuil_de_masquage_utilise
,GENP(BARY(FLOT(seuil_de_masquage_de_depart)
,FLOT(seuil_de_masquage_d_arrivee)
,DIVI(FLOT(NBRE(premiere_image,NUMERO_D_IMAGE)),FLOT(NBRE(premiere_image,derniere_image)))
)
)
);
/* Seuil de masquage utilise qui est proportionnel au numero courant (introduit le */
/* 20020308145352). */
Eblock
ATes
Bblock
Test(IL_FAUT(calculer_le_seuil_de_masquage))
Bblock
CALS(Ihistogramme(ImageA5));
/* Calcul de l'histogramme de l'image courante. */
EGAL(seuil_de_masquage_utilise,NOIR);
/* A priori... */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
Test(IFLT(ACCES_HISTOGRAMME_CUMULE___NORMALISE(niveau)
,COMP(fraction_de_points_pour_calculer_le_seuil_de_masquage)
)
)
Bblock
EGAL(seuil_de_masquage_utilise,niveau);
/* On prend comme seuil le niveau qui correspond a peu pres au poucentage demande. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EBoI
EGAL(seuil_de_masquage_utilise,MAX2(seuil_de_masquage_utilise,seuil_de_masquage));
/* On prend comme le seuil le niveau qui correspond a peu pres au poucentage demande, mais */
/* en faisant qu'il ne soit pas trop petit... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
MASQUE_IMAGES(seuil_de_masquage_utilise);
/* Activation du masquage des images. */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
Test(IL_FAUT(binariser_les_images))
Bblock
MODIFICATION_LISTE_DE_SUBSTITUTION(niveau
,MAX2(GENP(coordonnee_z_de_depth_cueing)
,COND(IL_FAUT(compatibilite_20091128)
,NOIR
,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 le 'z' de depth-cueing... */
/* */
/* La modification du 20091128095646 permet de ne pas faire disparaitre la premiere image */
/* car, en effet, dans son cas la substitution avant cette date se faisait avec 'NOIR'. */
/* Cela s'est vu lors du calcul de 'v $xiirc/MAND.T8 p=$xiP/fractal.11' */
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". */
Test(IL_FAUT(memoriser_le_Z_Buffer))
Bblock
CALS(Itranslation_3D(ImageR
,ImageA5
,tranche_verticale_courante
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on superpose les images avec gestion du 'Z-Buffer'... */
Eblock
ATes
Bblock
CALS(Itranslation(ImageR
,ImageA5
,ADRESSE(RRtranslation)
,FAUX
,FAUX
)
);
/* Et on superpose les images... */
Eblock
ETes
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_utilise);
/* 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(ImageR
,ImageA4
,FAUX
,ADRESSE(RRtranslation),ADRESSE(RAtranslation),ADRESSE(Atranslation)
,FZERO
,VRAI
)
);
/* Et on superpose les images (sans reinitialiser 'ImageR' a chaque iteration...). */
Eblock
ETes
DEMASQUE_IMAGES;
/* Inhibition du masquage... */
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,pas_des_tranches_verticales);
/* 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));
Test(IFET(IL_NE_FAUT_PAS(translation_quelconque),IZEQ(facteur_stereoscopique)))
Bblock
Test(IL_FAUT(memoriser_le_Z_Buffer))
Bblock
Test(IL_FAUT(memoriser_le_Z_Buffer_comme_une_image_standard))
Bblock
CALS(Ifloat_std_du_Z_Buffer(ImageA));
/* Conversion du 'Z-Buffer' en une image "standard"... */
CALi(Iupdate_image(nom_imageZ,ImageA));
Eblock
ATes
Bblock
CALi(IupdateF_image(nom_imageZ,Z_Buffer));
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
RETU_Commande;
Eblock
ECommande