/*************************************************************************************************************************************/
/* */
/* 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 " S E R I E D E T A Y L O R " : */
/* */
/* */
/* 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') : */
/* */
/* a b c */
/* X .Y .Z */
/* Cumul <-- Cumul + Image(i).---------- */
/* a!b!c! */
/* */
/* les 'Image(i)' donnant en fait les coefficients */
/* des developpements en serie de Taylor de fonctions */
/* arbitraires permettant de calculer des textures en */
/* tant qu'image Resultat. On notera bien que ces */
/* coefficients sont locaux a chaque point, puisqu'ils */
/* sont donnes par Image(i,X,Y). Ainsi, en chaque point */
/* {X,Y,Z} on peut se definir une fonction particuliere, */
/* dont les coefficients du developpement en serie de */
/* Taylor sont donnes successivement par les differentes */
/* images de la suite 'Image(i)'... */
/* */
/* */
/* Author of '$xci/accumule.03$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1992??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 EDITER_UNIQUEMENT_LA_SERIE_DE_TAYLOR \
FAUX \
/* Indique s'il ne faut qu'editer la serie de Taylor ('VRAI'), ou alors faire reellement */ \
/* les calculs ('FAUX'). */
#define ECHELLE_OX \
FU
#define ECHELLE_OY \
FU
/* Facteur d'echelle a apporter a 'X' et 'Y'. */
#define TRANSLATION_OX \
FZERO
#define TRANSLATION_OY \
FZERO
/* Translation a apporter a 'X' et 'Y'. */
#define VARIABLE_Z \
FU \
/* Variable 'Z' constante pour toute la serie d'integration. */
#define PUISSANCE_MAXIMALE \
DEUX \
/* Puissance maximale des monomes en {X,Y,Z} que l'on va utiliser. */
#define EXPOSANT_MAXIMAL_X \
DEUX
#define EXPOSANT_MAXIMAL_Y \
DEUX
#define EXPOSANT_MAXIMAL_Z \
DEUX
/* Exposants maximaux des trois variables 'X', 'Y' et 'Z'. */
#include xci/accumule.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#define TABULATION_DES_VARIABLES \
" " \
/* Chaine d'espaces utilisees pour tabuler correctement les variables 'X', 'Y et 'Z' lors */ \
/* de l'edition de la serie de Taylor. */
#define EDITION_D_UN_MONOME(variable,exposant) \
Bblock \
Test(IFNE(exposant,ZERO)) \
/* On notera que l'on utilise 'ZERO' et non pas 'EXPOSANT_MINIMAL_...' car en effet, le */ \
/* parametre 'EXPOSANT_MINIMAL_...' peut ne pas etre nul, or c'est vraiment la nullite que */ \
/* l'on veut tester ici (car quelque chose a la puissance zero vaut toujours un...). */ \
Bblock \
CAL3(Prme3(".%s%0*d",variable,nombre_de_chiffres,exposant)); \
/* Edition de la variable et de son exposant (on utilise 'nombre_de_chiffres' pour */ \
/* pour faire joli, mais ce n'est pas a proprement parler le bon parametre...). */ \
Eblock \
ATes \
Bblock \
CAL3(Prme2(" %.*s",nombre_de_chiffres,TABULATION_DES_VARIABLES)); \
/* Il n'y a que tabulation lorsque l'exposant de la variable est nul. On notera que la */ \
/* chaine " %.*s" de 'Prme2(...)' est "parallele" a ".%s%0*d" de 'Prme3(...)'. */ \
Eblock \
ETes \
Eblock \
/* Edition de l'une des variables d'un monome et de son exposant. */
#define EXPOSANT_MINIMAL_X \
ZERO
#define EXPOSANT_MINIMAL_Y \
ZERO
#define EXPOSANT_MINIMAL_Z \
ZERO
/* Exposants minimaux des trois variables 'X', 'Y' et 'Z'. */
#define variable_X \
MUL2(echelle_OX,ADD2(_____lNORMALISE_OX(X),translation_OX))
#define variable_Y \
MUL2(echelle_OY,ADD2(_____lNORMALISE_OY(Y),translation_OY))
/* Pour faire "pendant" a 'variable_Z'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 " S E R I E D E T A Y L O R " : */
/* */
/*************************************************************************************************************************************/
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(genere_Float,INIT(pas_des_images,FLOT(PAS_DES_IMAGES)));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(Logical,INIT(inverser_l_ordre_de_recuperation_des_images,INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES));
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */
/* */
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */
/* */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(genere_Float,INIT(numero_d_image,FLOT__UNDEF));
/* Numero de l'image courante. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Logical,INIT(editer_uniquement_la_serie_de_Taylor,EDITER_UNIQUEMENT_LA_SERIE_DE_TAYLOR));
/* Indique s'il ne faut qu'editer la serie de Taylor ('VRAI'), ou alors faire reellement */
/* les calculs ('FAUX'). */
DEFV(Float,INIT(echelle_OX,ECHELLE_OX));
DEFV(Float,INIT(echelle_OY,ECHELLE_OY));
/* Facteur d'echelle a apporter a 'X' et 'Y'. */
DEFV(Float,INIT(translation_OX,TRANSLATION_OX));
DEFV(Float,INIT(translation_OY,TRANSLATION_OY));
/* Translation a apporter a 'X' et 'Y'. */
DEFV(Float,INIT(variable_Z,VARIABLE_Z));
/* Variable 'Z' constante pour toute la serie d'integration. */
DEFV(Int,INIT(puissance_maximale,PUISSANCE_MAXIMALE));
/* Puissance maximale des monomes en {X,Y,Z} que l'on va utiliser. */
DEFV(Int,INIT(exposant_maximal_X,EXPOSANT_MAXIMAL_X));
DEFV(Int,INIT(exposant_maximal_Y,EXPOSANT_MAXIMAL_Y));
DEFV(Int,INIT(exposant_maximal_Z,EXPOSANT_MAXIMAL_Z));
/* Exposants maximaux des trois variables 'X', 'Y' et 'Z'. */
DEFV(Int,INIT(exposant_X,UNDEF));
DEFV(Int,INIT(exposant_Y,UNDEF));
DEFV(Int,INIT(exposant_Z,UNDEF));
/* Exposants courants des trois variables 'X', 'Y' et 'Z'. */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("postfixe=",nom_postfixe);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_F("premiere=",premiere_image);
GET_ARGUMENT_F("derniere=",derniere_image);
GET_ARGUMENT_F("pas=",pas_des_images);
GET_ARGUMENT_I("modulo=",translation_des_numeros_des_images);
GET_ARGUMENT_L("inverser=",inverser_l_ordre_de_recuperation_des_images);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_L("editer=",editer_uniquement_la_serie_de_Taylor);
GET_ARGUMENT_F("ex=""eX=""Ex=",echelle_OX);
GET_ARGUMENT_F("ey=""eY=""Ey=",echelle_OY);
GET_ARGUMENT_F("tX=""Tx=",translation_OX);
/* Le 20050623143612, "tx=" a ete supprime (double definition...). */
GET_ARGUMENT_F("tY=""Ty=",translation_OY);
/* Le 20050623143612, "ty=" a ete supprime (double definition...). */
GET_ARGUMENT_F("z=""Z=",variable_Z);
GET_ARGUMENT_I("p=",puissance_maximale);
GET_ARGUMENT_I("emx=""emX=",exposant_maximal_X);
GET_ARGUMENT_I("emy=""emY=",exposant_maximal_Y);
GET_ARGUMENT_I("emz=""emZ=",exposant_maximal_Z);
)
);
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... */
BDEFV(imageF,monome_courant);
/* Image flottante dans laquelle on trouve le monome courant. */
Test(IL_FAUT(editer_uniquement_la_serie_de_Taylor))
Bblock
Eblock
ATes
Bblock
CALi(IFinitialisation(cumul_des_couches,FZERO));
/* Nettoyage de l'image finale flottante... */
Eblock
ETes
EGAL(numero_d_image,premiere_image);
/* Positionnement sur la premiere image. */
DoIn(exposant_X,EXPOSANT_MINIMAL_X,exposant_maximal_X,I)
Bblock
/* Calcul d'un exposant 'eX' possible pour la variable 'X'. */
DoIn(exposant_Y,EXPOSANT_MINIMAL_Y,exposant_maximal_Y,I)
Bblock
/* Calcul d'un exposant 'eY' possible pour la variable 'Y'. */
DoIn(exposant_Z,EXPOSANT_MINIMAL_Z,exposant_maximal_Z,I)
Bblock
/* Calcul d'un exposant 'eZ' possible pour la variable 'Z'. */
Test(IFLE(ADD3(exposant_X,exposant_Y,exposant_Z),puissance_maximale))
Bblock
/* Le triplet (eX,eY,eZ) des exposants des trois variables 'X', 'Y' et 'Z' n'est valide que */
/* si leur somme est inferieure ou egale a la puissance maximale des monomes. */
Test(IFLE(numero_d_image,derniere_image))
Bblock
/* Ce processus est repete tant que l'on n'a pas epuise l'ensemble des images Argument. On */
/* notera la relation suivante : */
/* */
/* supposons que la variable 'Z' soit ignoree, on prend donc : */
/* */
/* emz=0 */
/* */
/* Soit 'p' le degre maximal des monomes ('puissance_maximale') ; il va donc y avoir : */
/* */
/* 1 monome de degre 0 : 1 */
/* */
/* 2 monomes de degre 1 : x, y */
/* */
/* 2 2 */
/* 3 monomes de degre 2 : x , x.y, y */
/* */
/* 3 2 2 3 */
/* 4 monomes de degre 3 : x , x .y , x.y , y */
/* */
/* . . . . */
/* . . . . */
/* . . . . */
/* p p-1 p-1 p */
/* p+1 monomes de degre p : x , x .y, ..., x.y , y */
/* */
/* Soit au total : */
/* */
/* (p+1).(p+2) */
/* 1 + 2 + 3 + 4 + ... + (p+1) = ------------- monomes */
/* 2 */
/* */
/* Soit alors 'N' le nombre d'images ; il faudrait donc que l'on ait theoriquement : */
/* */
/* (p+1).(p+2) */
/* ------------- = N */
/* 2 */
/* */
/* ou : */
/* */
/* (p+1).(p+2) = 2.N */
/* */
/* 2 */
/* p + 3.p + 2.(1-N) = 0 */
/* */
/* 'p' etant un nombre entier. */
/* */
/* Le discriminant 'D' vaut : */
/* */
/* 2 */
/* D = 3 - 4.1.2.(1-N) */
/* */
/* D = 1 + 8.N */
/* */
/* qui doit donc etre un carre, pour que 'p' ait une chance d'etre entier. 'D' est d'autre */
/* part impair. La racine 'p' positive vaut : */
/* __ */
/* / */
/* -3 + \/ D */
/* p = ------------ */
/* 2 */
/* */
/* pour que 'p' soit entier, il faut que le numerateur soit pair, et que donc la racine */
/* du discriminant soit impaire (puisque la difference de deux nombres impairs est paire, */
/* et que '3' est impair). On arrive donc aux solutions : */
/* */
/* __ */
/* | / | | */
/* D | \/ D | N | p */
/* | | | */
/* -----|-------|-----|----- */
/* 25 | 5 | 3 | 1 */
/* -----|-------|-----|----- */
/* 49 | 7 | 6 | 2 */
/* -----|-------|-----|----- */
/* 81 | 9 | 10 | 3 */
/* -----|-------|-----|----- */
/* 121 | 11 | 15 | 4 */
/* -----|-------|-----|----- */
/* 169 | 13 | 21 | 5 */
/* -----|-------|-----|----- */
/* 225 | 15 | 28 | 6 */
/* -----|-------|-----|----- */
/* 289 | 17 | 36 | 7 */
/* -----|-------|-----|----- */
/* 361 | 19 | 45 | 8 */
/* -----|-------|-----|----- */
/* 441 | 21 | 55 | 9 */
/* -----|-------|-----|----- */
/* 529 | 23 | 66 | 10 */
/* -----|-------|-----|----- */
/* 625 | 25 | 78 | 11 */
/* -----|-------|-----|----- */
/* 729 | 27 | 91 | 12 */
/* -----|-------|-----|----- */
/* 841 | 29 | 105 | 13 */
/* -----|-------|-----|----- */
/* 961 | 31 | 120 | 14 */
/* */
/* avec : */
/* */
/* D-1 */
/* N = ----- */
/* 8 */
/* */
Test(IFNE(numero_d_image,fINTE(numero_d_image)))
Bblock
PRINT_ATTENTION("le numero de l'image courante n'est pas entier, il va 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
)
)
);
/* Notons I(0) la premiere image. */
/* */
/* Voici un premier exemple : */
/* */
/* eX E [0,2] */
/* eY = 0 */
/* eZ = 0 */
/* */
/* (eX) <= 2 */
/* */
/* on a alors les associations suivantes : */
/* */
/* 0 */
/* I(0) --0--> X */
/* */
/* 1 */
/* I(1) --0--> X */
/* */
/* 2 */
/* I(2) --0--> X */
/* */
/* */
/* Voici un second exemple : */
/* */
/* eX E [0,2] */
/* eY E [0,2] */
/* eZ = 0 */
/* */
/* (eX+eY) <= 2 */
/* */
/* on a alors les associations suivantes : */
/* */
/* 0 0 */
/* I(0) --0--> X .Y */
/* */
/* 0 1 */
/* I(1) --0--> X .Y */
/* */
/* 0 2 */
/* I(2) --0--> X .Y */
/* */
/* 1 0 */
/* I(3) --0--> X .Y */
/* */
/* 1 1 */
/* I(4) --0--> X .Y */
/* */
/* 2 0 */
/* I(5) --0--> X .Y */
/* */
/* */
/* Voici un troisieme exemple : */
/* */
/* eX E [0,2] */
/* eY E [0,2] */
/* eZ E [0,2] */
/* */
/* (eX+eY+eZ) <= 2 */
/* */
/* on a alors les associations suivantes : */
/* */
/* 0 0 0 */
/* I(0) --0--> X .Y .Z */
/* */
/* 0 0 1 */
/* I(1) --0--> X .Y .Z */
/* */
/* 0 0 2 */
/* I(2) --0--> X .Y .Z */
/* */
/* 0 1 0 */
/* I(3) --0--> X .Y .Z */
/* */
/* 0 1 1 */
/* I(4) --0--> X .Y .Z */
/* */
/* 0 2 0 */
/* I(5) --0--> X .Y .Z */
/* */
/* 1 0 0 */
/* I(6) --0--> X .Y .Z */
/* */
/* 1 0 1 */
/* I(7) --0--> X .Y .Z */
/* */
/* 1 1 0 */
/* I(8) --0--> X .Y .Z */
/* */
/* 2 0 0 */
/* I(9) --0--> X .Y .Z */
/* */
/* */
/* Le 20221212114347, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(IL_FAUT(editer_uniquement_la_serie_de_Taylor))
Bblock
CAL3(Prme2("+ I(%0*d)",nombre_de_chiffres,INTE(numero_d_image)));
/* Edition du numero courant de l'image. */
EDITION_D_UN_MONOME("x",exposant_X);
/* Edition de la variable 'X' et de son exposant. */
EDITION_D_UN_MONOME("y",exposant_Y);
/* Edition de la variable 'Y' et de son exposant. */
EDITION_D_UN_MONOME("z",exposant_Z);
/* Edition de la variable 'Z' et de son exposant. */
CALS(Fsauts_de_lignes(UN));
Eblock
ATes
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_image))))
Bblock
/* 'ImageA' donne la couche a l'instant courant, */
CALS(Istd_float(couche_courante
,FLOT__NOIR
,FLOT__BLANC
,ImageA
)
);
/* Que l'on convertit en flottant... */
begin_image
Bblock
storeF_point(DIVI(NEUT(MUL3(PUIX(variable_X,exposant_X)
,PUIX(variable_Y,exposant_Y)
,PUIX(variable_Z,exposant_Z)
)
)
,MUL3(FACT(exposant_X)
,FACT(exposant_Y)
,FACT(exposant_Z)
)
)
,monome_courant
,X,Y
);
/* Calcul du monome courant en chacun des points de l'image, c'est-a-dire la quantite : */
/* */
/* eX eY eZ */
/* X .Y .Z */
/* ------------- */
/* eX!eY!eZ! */
/* */
/* ou 'X', 'Y' et 'Z' representent les coordonnees normalisees dans [0,1] avec une */
/* translation et un facteur d'echelle eventuels. */
/* */
/* Cette formule s'obtient de la facon suivante lorsque l'on veut calculer une quantite du */
/* type : */
/* */
/* n */
/* S = (x+y+z) */
/* n */
/* */
/* k=n */
/* ___ */
/* \ k n-k k */
/* S = /__ C .x .(y+z) */
/* n n */
/* k=0 */
/* */
/* */
/* k=n p=k */
/* ___ ___ */
/* \ k n-k \ p k-p p */
/* S = /__ C .x ./__ C .y .z */
/* n n k */
/* k=0 p=0 */
/* */
/* */
/* k=n p=k */
/* ___ ___ */
/* \ \ k p n-k k-p p */
/* S = /__ /__ C C .x .y .z */
/* n n k */
/* k=0 p=0 */
/* */
/* or : */
/* */
/* k p n! k! n! */
/* C .C = ----------.---------- = ---------------- */
/* n k (n-k)!k! (k-p)!p! (n-k)!(k-p)!p! */
/* */
/* d'ou : */
/* */
/* k=n p=k */
/* ___ ___ */
/* \ \ n! n-k k-p p */
/* S = /__ /__ ----------------.x .y .z */
/* n (n-k)!(k-p)!p! */
/* k=0 p=0 */
/* */
/* or une serie de Taylor pour une fonction de trois variables est du type symbolique : */
/* */
/* n=N */
/* ___ */
/* \ 1 d d d n */
/* f(x+a,y+b,z+c) = f(x,y,z) + /__ ----.(a.---- + b.---- + c.----) f(x,y,z) + Reste */
/* n! dx dy dz */
/* n=1 */
/* */
/* \______________________/ */
/* */
/* S */
/* n */
/* */
/* d'ou la formule annoncee puisqu'on trouve ci-dessus au numerateur et au denominateur n! */
/* qui s'eliminent l'un l'autre... */
Eblock
end_image
CALS(IFmultiplication(couche_courante
,couche_courante
,monome_courant
)
);
/* Puis attenuation a l'aide de la matrice de monomes. */
CALS(IFaddition(cumul_des_couches,cumul_des_couches,couche_courante));
/* Et on cumule d'avant en arriere par addition arithmetique. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
INCR(numero_d_image,pas_des_images);
/* Passage a l'image suivante. Ce comptage n'est fait que tant que le traitement est licite. */
CALZ_FreCC(nom_image);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Eblock
EDoI
Eblock
EDoI
Test(IL_FAUT(editer_uniquement_la_serie_de_Taylor))
Bblock
CALS(Fsauts_de_lignes(UN));
Eblock
ATes
Bblock
CALS(Ifloat_std_avec_renormalisation(ImageR,cumul_des_couches));
/* Contrairement a 'v $xci/accumule.01$K', ou l'on peut choisir entre renormaliser et ne pas */
/* renormaliser, ici il faut le faire systematiquement, car en effet, la ponderation au */
/* niveau d'une couche n'est plus constante, mais varie d'un point a l'autre (en fonction */
/* de 'X', 'Y' et 'Z'). */
CALi(Iupdate_image(nom_imageR,ImageR));
Eblock
ETes
EDEFV(imageF,monome_courant);
/* Image flottante dans laquelle on trouve le monome courant. */
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