/*************************************************************************************************************************************/
/* */
/* P R I M I T I V E S D ' A C C E S A U X P I X E L S S O U S F O R M E D E " D E F I N E S " : */
/* */
/* */
/* Definition : */
/* */
/* Dans ce fichier, se trouvent toutes */
/* les fonctions primitives d'acces aux */
/* pixels d'une image ; elles sont exprimees */
/* sous forme de "defines" afin de reduire */
/* la duree de l'execution. */
/* */
/* */
/* N O T A T I O N S : */
/* */
/* */
/* On notera 'imageA' les images Arguments, */
/* et 'imageR' les images Resultats ; 'arg' */
/* designera des arguments, et 'Vf' une */
/* fonction "variable"... */
/* */
/* */
/* Author of '$xiipd/fonction.1$FON' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19870000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S " B U G S " P R E S E N T S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : le 20061124142825 '_____BUG_SYSTEME_C_complexite_01' a ete installe dans */
/* 'v $xiii/Images$STR _____BUG_SYSTEME_C_complexite_01' car, en effet, le fichier dans */
/* lequel nous sommes ('v $xiipd/fonction.1$FON') n'est pas compile (au passage le directory */
/* '$xbipd' n'existe pas...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S N I V E A U X A B S O L U S E T R E L A T I F S : */
/* */
/*************************************************************************************************************************************/
/* Enfin, on notera que l'utilisation courante sera du type : */
/* */
/* GENP(NIVA(...FLOT(NIVR(...)))) */
/* */
/* ou si necessaire : */
/* */
/* GENP(TRNP(NIVA(...FLOT(NIVR(...))))) */
/* */
/* en notant bien l'importance de l'ordres des operations ; en particulier 'TRNP(...)' */
/* qui fait un 'TRON(...)' dans [NOIR,BLANC] doit preceder imperativement 'GENP(...)' qui */
/* ferait une troncation automatique... */
%define NIVA(niveau) \
ADD2(niveau,NOIR)
/* Mise du niveau en absolu (par rapport au 'NOIR'). */
%define NIVR(niveau) \
SOUS(niveau,NOIR)
/* Mise du niveau en relatif. */
/* On notera que 'NIVA(...)' et 'NIVR(...)' */
/* sont definis par "%define" et non par "#define" afin de pouvoir utiliser le nouvel */
/* operateur de concatenation "`" du pre-processeur : il faut que leur substitution ait */
/* lieu apres la gestion de cet operateur de concatenation... */
/* Enfin, on notera que l'utilisation courante sera du type : */
/* */
/* GENP(NIVA(...FLOT(NIVR(...)))) */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R N E U T R E : */
/* */
/*************************************************************************************************************************************/
#define VNEUT(argument) \
NEUT(argument) \
/* Introduit le 20151125175653 pour 'v $xci/histogramme$K VNEUT'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E N V O I D U P R E M I E R A R G U M E N T : */
/* */
/*************************************************************************************************************************************/
#define VNEUTRE1(arg1,arg2) \
NEUT(arg1)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E N V O I D U D E U X I E M E A R G U M E N T ( D E U X S O L U T I O N S ) : */
/* */
/*************************************************************************************************************************************/
#define VNEUTRE2(arg1,arg2) \
NEUT(arg2)
#define VNEUTRE(arg1,arg2) \
VNEUTRE2(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L E U R A B S O L U E D ' U N E V A L E U R : */
/* */
/*************************************************************************************************************************************/
#define VABS(argument) \
NIVA(ABSO(NIVR(argument)))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A D D I T I O N D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define VADD(arg1,arg2) \
NIVA(ADD2(NIVR(arg1),NIVR(arg2)))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S O U S T R A C T I O N D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define VSUB(arg1,arg2) \
NIVA(SOUS(arg1,arg2))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M P L E M E N T A T I O N D ' U N E V A L E U R : */
/* */
/*************************************************************************************************************************************/
#define VCOMP(argument) \
VSUB(BLANC,argument)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L I C A T I O N D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define VMUL(arg1,arg2) \
MUL2(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L I C A T I O N D E D E U X V A L E U R S ( F L O T T A N T E E T E N T I E R E ) : */
/* */
/*************************************************************************************************************************************/
#define VMULF(arg1,arg2) \
MUL2(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I V I S I O N D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define VDIV(arg1,arg2) \
DIVI(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A X I M U M D E D E U X V A L E U R S ( " O U " F L O U ) : */
/* */
/*************************************************************************************************************************************/
#define VMAX(arg1,arg2) \
MAX2(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M I N I M U M D E D E U X V A L E U R S ( " E T " F L O U ) : */
/* */
/*************************************************************************************************************************************/
#define VMIN(arg1,arg2) \
MIN2(arg1,arg2)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " O U " E X C L U S I F F L O U D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define VMINMAX(arg1,arg2) \
VMAX(VMIN(arg1,VCOMP(arg2)),VMIN(VCOMP(arg1),arg2))
#define VMAXMIN(arg1,arg2) \
VMIN(VMAX(arg1,VCOMP(arg2)),VMAX(VCOMP(arg1),arg2)) \
/* Introduit le 20061023092103 par "symetrie" avec 'VMINMAX(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' O R ' D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define VOR(arg1,arg2) \
OUIN(arg1,arg2)
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' A N D ' D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define VAND(arg1,arg2) \
ETLO(arg1,arg2)
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' E O R ' D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define VEOR(arg1,arg2) \
OUEX(arg1,arg2)
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N V E R S I O N D ' U N E V A L E U R : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define VINVERT(argument) \
VEOR(BLANC,argument)
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* H I E R A R C H I E D E S F O N C T I O N S D E C H A R G E M E N T : */
/* */
/* */
/* loadQ_point_GENERAL */
/* loadQ_point */
/* load_point */
/* loadNS_point */
/* loadS_point */
/* loadS_point_valide */
/* load_point_valide */
/* loadNS_point_valide */
/* loadC_point_valide */
/* loadI_point_valide */
/* loadF_point_valide */
/* loadF_point_continu */
/* loadF_point_continu_cubique */
/* loadF_point_continu_lineaire */
/* loadD_point_valide */
/* load_point_modulo */
/* loadC_point_modulo */
/* loadI_point_modulo */
/* loadF_point_modulo */
/* loadD_point_modulo */
/* loadC_point */
/* loadIB_point */
/* loadI_point */
/* loadUB_point */
/* loadU_point */
/* loadF_point */
/* loadD_point */
/* loadJ_point */
/* loadJ_point_modulo */
/* loadRJ_point */
/* loadRJ_point_modulo */
/* loadIJ_point */
/* loadIJ_point_modulo */
/* loadHJ_point */
/* loadHJ_point_modulo */
/* loadRHJ_point */
/* loadRHJ_point_modulo */
/* loadIHJ_point */
/* loadIHJ_point_modulo */
/* loadJHJ_point */
/* loadJHJ_point_modulo */
/* loadKHJ_point */
/* loadKHJ_point_modulo */
/* */
/* AloadQ_point_GENERAL */
/* Aload_point */
/* Aload_point_valide */
/* AloadF_point */
/* AloadF_point_valide */
/* AloadI_point */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T G E N E R A L D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define loadQ_point_GENERAL(imageA,X,Y) \
IMAGE(imageA,X,Y)
#define AloadQ_point_GENERAL(albumA,X,Y,Z) \
ALBUM(albumA,X,Y,Z)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#if ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
)
# define loadQ_point(imageA,X,Y) \
COND(TEST_MASQUE_ACTIF(X,Y,MASQUER_LOAD) \
,loadQ_point_GENERAL(imageA,X,Y) \
,NIVEAU_MASQUE \
)
#Aif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
)
#Eif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
)
#if ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
# define loadQ_point(imageA,X,Y) \
COND_MASQUE_NON_ACTIF(X,Y,MASQUER_LOAD \
,loadQ_point_GENERAL(imageA,X,Y) \
,NIVEAU_MASQUE \
) \
/* Avant le 19970219155451, 'loadQ_point(...)' etait defini par : */ \
/* */ \
/* COND(TEST_MASQUE_ACTIF(X,Y,MASQUER_LOAD) \ */ \
/* ,loadQ_point_GENERAL(imageA,X,Y) \ */ \
/* ,NIVEAU_MASQUE \ */ \
/* ) */ \
/* */ \
/* mais des tests avec 'v $xB/SGO200A1$D/CC$D/performan.04$c' ont montre que de faire */ \
/* en "une fois" les tests 'TEST_MASQUE_ACTIF(X,Y,MASQUER_LOAD)' bloquait considerablement */ \
/* l'optimisation, d'ou cette version... */
#Aif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
#Eif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " ( A V E C M A S Q U A G E ) : */
/* */
/*************************************************************************************************************************************/
#define load_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
#define Aload_point(albumA,X,Y,Z) \
AloadQ_point_GENERAL(albumA,X,Y,Z)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " */
/* S A N S S U B S T I T U T I O N " I N V E R S E " : */
/* */
/*************************************************************************************************************************************/
#define loadNS_point(imageA,X,Y) \
load_point(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " */
/* A V E C S U B S T I T U T I O N " I N V E R S E " : */
/* */
/*************************************************************************************************************************************/
#define loadS_point(imageA,X,Y) \
COND(EST_INACTIF_FILTRAGE \
,load_point(imageA,X,Y) \
,Nsubstitution_inverse(loadQ_point(imageA,X,Y)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define loadC_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define loadIB_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
#define AloadIB_point(albumA,X,Y,Z) \
AloadQ_point_GENERAL(albumA,X,Y,Z) \
/* Introduit le 20100326182837... */
#define loadI_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
#define AloadI_point(albumA,X,Y,Z) \
AloadQ_point_GENERAL(albumA,X,Y,Z) \
/* Introduit le 20050909143052... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " P O S I T I V E " : */
/* */
/*************************************************************************************************************************************/
#define loadUB_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
#define loadU_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define loadF_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
#define AloadF_point(albumA,X,Y,Z) \
AloadQ_point_GENERAL(albumA,X,Y,Z)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define loadD_point(imageA,X,Y) \
loadQ_point(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
#define loadJ_point(imageA,X,Y) \
loadQ_point_GENERAL(imageA,X,Y) \
/* Chargement du nombre complexe. */
#define loadRJ_point(imageA,X,Y) \
Reelle(loadJ_point(imageA,X,Y)) \
/* Chargement de la partie reelle. */
#define loadIJ_point(imageA,X,Y) \
Imaginaire(loadJ_point(imageA,X,Y)) \
/* Chargement de la partie imaginaire. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " C O M P L E X E " M O D U L O : */
/* */
/*************************************************************************************************************************************/
#define loadJ_point_modulo(imageA,X,Y) \
loadJ_point(imageA,MODX(X),MODY(Y)) \
/* Chargement du nombre complexe modulo. */
#define loadRJ_point_modulo(imageA,X,Y) \
Reelle(loadJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie reelle modulo... */
#define loadIJ_point_modulo(imageA,X,Y) \
Imaginaire(loadJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie imaginaire modulo... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
#define loadHJ_point(imageA,X,Y) \
loadQ_point_GENERAL(imageA,X,Y) \
/* Chargement du nombre hyper-complexe. */
#define loadRHJ_point(imageA,X,Y) \
HReelle(loadHJ_point(imageA,X,Y)) \
/* Chargement de la partie reelle. */
#define loadIHJ_point(imageA,X,Y) \
HImaginaire(loadHJ_point(imageA,X,Y)) \
/* Chargement de la partie imaginaire. */
#define loadJHJ_point(imageA,X,Y) \
HJmaginaire(loadHJ_point(imageA,X,Y)) \
/* Chargement de la partie jmaginaire. */
#define loadKHJ_point(imageA,X,Y) \
HKmaginaire(loadHJ_point(imageA,X,Y)) \
/* Chargement de la partie kmaginaire. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " H Y P E R - C O M P L E X E " M O D U L O : */
/* */
/*************************************************************************************************************************************/
#define loadHJ_point_modulo(imageA,X,Y) \
loadHJ_point(imageA,MODX(X),MODY(Y)) \
/* Chargement du nombre hyper-complexe modulo. */
#define loadRHJ_point_modulo(imageA,X,Y) \
HReelle(loadHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie reelle modulo... */
#define loadIHJ_point_modulo(imageA,X,Y) \
HImaginaire(loadHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie imaginaire modulo... */
#define loadJHJ_point_modulo(imageA,X,Y) \
HJmaginaire(loadHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie jmaginaire modulo... */
#define loadKHJ_point_modulo(imageA,X,Y) \
HKmaginaire(loadHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie kmaginaire modulo... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " H Y P E R - H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
/* Toutes les definitions suivantes ont ete introduites le 20150227102109... */
#define loadHHJ_point(imageA,X,Y) \
loadQ_point_GENERAL(imageA,X,Y) \
/* Chargement du nombre hyper-hyper-complexe. */
#define loadRHHJ_point(imageA,X,Y) \
HHReelle(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie reelle. */
#define loadIHHJ_point(imageA,X,Y) \
HHImaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie imaginaire. */
#define loadJHHJ_point(imageA,X,Y) \
HHHJmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie jmaginaire. */
#define loadKHHJ_point(imageA,X,Y) \
HHKmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie kmaginaire. */
#define loadSHHJ_point(imageA,X,Y) \
HHSmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie smaginaire. */
#define loadTHHJ_point(imageA,X,Y) \
HHTmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie tmaginaire. */
#define loadUHHJ_point(imageA,X,Y) \
HHUmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie umaginaire. */
#define loadVHHJ_point(imageA,X,Y) \
HHVmaginaire(loadHHJ_point(imageA,X,Y)) \
/* Chargement de la partie vmaginaire. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A R G E M E N T D ' U N P O I N T " H Y P E R - H Y P E R - C O M P L E X E " M O D U L O : */
/* */
/*************************************************************************************************************************************/
/* Toutes les definitions suivantes ont ete introduites le 20150227102109... */
#define loadHHJ_point_modulo(imageA,X,Y) \
loadHHJ_point(imageA,MODX(X),MODY(Y)) \
/* Chargement de la partie reelle et de la partie imaginaire modulo... */
#define loadRHHJ_point_modulo(imageA,X,Y) \
HHReelle(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie reelle modulo... */
#define loadIHHJ_point_modulo(imageA,X,Y) \
HHImaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie imaginaire modulo... */
#define loadJHHJ_point_modulo(imageA,X,Y) \
HHJmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie jmaginaire modulo... */
#define loadKHHJ_point_modulo(imageA,X,Y) \
HHKmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie kmaginaire modulo... */
#define loadSHHJ_point_modulo(imageA,X,Y) \
HHSmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie smaginaire modulo... */
#define loadTHHJ_point_modulo(imageA,X,Y) \
HHTmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie tmaginaire modulo... */
#define loadUHHJ_point_modulo(imageA,X,Y) \
HHUmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie umaginaire modulo... */
#define loadVHHJ_point_modulo(imageA,X,Y) \
HHVmaginaire(loadHHJ_point_modulo(imageA,X,Y)) \
/* Chargement de la partie vmaginaire modulo... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
#define load_point_valide(imageA,X,Y) \
COND(TEST_HORS_IMAGE(X,Y) \
,NIVEAU_HORS_IMAGE(imageA,X,Y) \
/* Cas des points {X,Y} hors de l'ecran [Xmin,Xmax][Ymin,Ymax]. */ \
,load_point(imageA,X,Y) \
/* Cas des points {X,Y} dans l'ecran [Xmin,Xmax][Ymin,Ymax]. */ \
)
#define Aload_point_valide(albumA,X,Y,Z) \
COND(TEST_HORS_ALBUM(X,Y,Z) \
,NIVEAU_HORS_ALBUM(albumA,X,Y,Z) \
/* Cas des points {X,Y,Z} hors de l'ecran [Xmin,Xmax][Ymin,Ymax][Zmin,Zmax]. */ \
,Aload_point(albumA,X,Y,Z) \
/* Cas des points {X,Y,Z} dans l'ecran [Xmin,Xmax][Ymin,Ymax][Zmin,Zmax]. */ \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " */
/* S A N S S U B S T I T U T I O N " I N V E R S E " : */
/* */
/*************************************************************************************************************************************/
#define loadNS_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " */
/* A V E C S U B S T I T U T I O N " I N V E R S E " : */
/* */
/*************************************************************************************************************************************/
#define loadS_point_valide(imageA,X,Y) \
COND(TEST_HORS_IMAGE(X,Y) \
,NIVEAU_HORS_IMAGE(imageA,X,Y) \
/* Cas des points {X,Y} hors de l'ecran [Xmin,Xmax][Ymin,Ymax]. */ \
,loadS_point(imageA,X,Y) \
/* Cas des points {X,Y} dans l'ecran [Xmin,Xmax][Ymin,Ymax]. */ \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define loadC_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define loadIB_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y)
#define loadI_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define loadF_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y) \
/* ATTENTION : je rappelle le 20170826104520 que 'loadF_point_valide(...)' utilise donc le */ \
/* meme 'NIVEAU_HORS_IMAGE(...)' que 'loadF_point_valide(...)', qui est donc de type */ \
/* 'genere_p' et non pas 'genere_Float'... */
#define AloadF_point_valide(albumA,X,Y,Z) \
Aload_point_valide(albumA,X,Y,Z) \
/* ATTENTION : je rappelle le 20170826104520 que 'AloadF_point_valide(...)' utilise donc le */ \
/* meme 'NIVEAU_HORS_ALBUM(...)' que 'AloadF_point_valide(...)', qui est donc de type */ \
/* 'genere_p' et non pas 'genere_Float'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S C H A R G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define loadD_point_valide(imageA,X,Y) \
load_point_valide(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S C H A R G E M E N T D ' U N P O I N T " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
#define load_point_modulo(imageA,X,Y) \
load_point(imageA,MODX(X),MODY(Y))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S C H A R G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define loadC_point_modulo(imageA,X,Y) \
load_point_modulo(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S C H A R G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define loadIB_point_modulo(imageA,X,Y) \
load_point_modulo(imageA,X,Y)
#define loadI_point_modulo(imageA,X,Y) \
load_point_modulo(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S C H A R G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define loadF_point_modulo(imageA,X,Y) \
load_point_modulo(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S C H A R G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define loadD_point_modulo(imageA,X,Y) \
load_point_modulo(imageA,X,Y)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* H I E R A R C H I E D E S F O N C T I O N S D E R A N G E M E N T : */
/* */
/* */
/* storeQ_point_GENERAL */
/* storeQ_point_FAST */
/* storeQ_point */
/* store_point */
/* storeQ_point_valide */
/* store_point_valide */
/* storeQ_point_modulo */
/* store_point_modulo */
/* storeQV_point */
/* storeC_point */
/* storeIB_point */
/* storeI_point */
/* storeUB_point */
/* storeU_point */
/* storeF_point */
/* storeD_point */
/* storeQV_point_valide */
/* storeC_point_valide */
/* storeIB_point_valide */
/* storeI_point_valide */
/* storeUB_point_valide */
/* storeU_point_valide */
/* storeF_point_valide */
/* storeD_point_valide */
/* storeQV_point_modulo */
/* storeC_point_modulo */
/* storeIB_point_modulo */
/* storeI_point_modulo */
/* storeUB_point_modulo */
/* storeU_point_modulo */
/* storeF_point_modulo */
/* storeD_point_modulo */
/* storeJ_point */
/* storeJ_point_valide */
/* storeRJ_point */
/* storeRJ_point_valide */
/* storeIJ_point */
/* storeIJ_point_valide */
/* storeHJ_point */
/* storeRHJ_point */
/* storeIHJ_point */
/* storeJHJ_point */
/* storeKHJ_point */
/* */
/* AstoreQ_point_GENERAL */
/* Astore_point */
/* AstoreQ_point_valide */
/* Astore_point_valide */
/* AstoreF_point */
/* AstoreF_point_valide */
/* AstoreI_point */
/* AstoreI_point_valide */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T G E N E R A L D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define storeQ_point_GENERAL(valeur,imageR,X,Y,loadX_point,Vf,Calibrage,selecteur) \
Bblock \
DEFV(Int,INIT(X_local,X)); \
DEFV(Int,INIT(Y_local,Y)); \
/* Optimisation de la compilation introduite le 20120321185221 afin de prevenir les cas */ \
/* ou {X,Y} sont des expressions "lourdes"... */ \
\
EGAL(selecteur(IMAGE(imageR,X_local,Y_local)),valeur); \
Eblock \
/* ATTENTION : il ne faut surtout pas mettre de 'GENP' pour positionner */ \
/* correctement 'valeur', car en effet, toutes les operations 'store' */ \
/* passent par ici, et par exemple le 'storeF' ; enfin, le 'selecteur' est */ \
/* utilise par les images "complexes"... */
#define AstoreQ_point_GENERAL(valeur,albumR,X,Y,Z,selecteur) \
Bblock \
DEFV(Int,INIT(X_local,X)); \
DEFV(Int,INIT(Y_local,Y)); \
DEFV(Int,INIT(Z_local,Z)); \
/* Optimisation de la compilation introduite le 20120321185221 afin de prevenir les cas */ \
/* ou {X,Y,Z} sont des expressions "lourdes"... */ \
\
EGAL(selecteur(ALBUM(albumR,X_local,Y_local,Z_local)),valeur); \
Eblock \
/* ATTENTION : il ne faut surtout pas mettre de 'GENP' pour positionner correctement */ \
/* 'valeur', car en effet, toutes les operations 'store' passent par ici ; enfin, le */ \
/* 'selecteur' peut etre utilise par les albums "complexes"... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T S U P E R - R A P I D E D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define storeQ_point_FAST(valeur,imageR,X,Y,loadX_point,Vf,Calibrage) \
Bblock \
storeQ_point_GENERAL(valeur,imageR,X,Y,loadX_point,Vf,Calibrage,NEUT); \
Eblock \
/* ATTENTION : il ne faut surtout pas mettre de 'GENP' pour positionner */ \
/* correctement 'valeur', car en effet, toutes les operations 'store' */ \
/* passent par ici, et par exemple le 'storeF'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define storeQ_point(valeur,imageR,X,Y,loadX_point,Vf,Calibrage) \
Bblock \
Test(EST_INACTIF_FILTRAGE) \
Bblock \
storeQ_point_FAST(valeur \
,imageR \
,X,Y \
,loadX_point,Vf,Calibrage \
); \
/* "Point de passage" le plus rapide... */ \
/* */ \
/* Je note le 20170715132317 que c'est le point de passage par defaut... */ \
Eblock \
ATes \
Bblock \
Test(IL_FAUT(ne_faire_que_les_substitutions)) \
Bblock \
storeQ_point_FAST(Nsubstitution(valeur) \
,imageR \
,X,Y \
,loadX_point,Vf,Calibrage \
); \
/* "Point de passage" intermediaire... */ \
Eblock \
ATes \
Bblock \
Test(TEST_MASQUE_ACTIF(X,Y,MASQUER_STORE)) \
Bblock \
Test(EST_AUTORISE(Necrasement(loadX_point(imageR,X,Y)))) \
Bblock \
storeQ_point_FAST(Nsubstitution(Calibrage(Vf(loadX_point(imageR,X,Y) \
,GENP(valeur) \
) \
) \
) \
,imageR \
,X,Y \
,loadX_point,Vf,Calibrage \
); \
/* "Point de passage" le plus lent... */ \
/* */ \
/* Le 20170715081804, suite a 'v $xiipf/fonction.2$DEF 20170715081454', la fonction */ \
/* 'Vf(...)' n'est plus accedee via un 'fPOINTEUR(...)'... */ \
/* */ \
/* Je note le 20170715132317 que pour passer par ici, il faut : */ \
/* */ \
/* ne_faire_que_les_substitutions = FAUX */ \
/* etat_Filtrage_niveaux = VRAI (equivalent a 'ACTIF'). */ \
/* */ \
/* */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
#define store_point(valeur,imageR,X,Y,Vf) \
Bblock \
storeQ_point(GENP(valeur),imageR,X,Y,load_point,Vf,Ncalibrage); \
Eblock
#define Astore_point(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_GENERAL(GENP(valeur),albumR,X,Y,Z,NEUT); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " C H A R " / " I N T " / " F L O A T " : */
/* */
/* */
/* Nota : */
/* */
/* Pour les "store" de types differents */
/* de 'genere_p', on ne peut appliquer la */
/* fonction 'Vf', car en effet le type de */
/* ses arguments est variable, alors que */
/* dans son corps, il est fixe... */
/* */
/*************************************************************************************************************************************/
#define storeQV_point(valeur,imageR,X,Y) \
Bblock \
Test(EST_INACTIF_FILTRAGE) \
Bblock \
storeQ_point_FAST(valeur,imageR,X,Y,loadX_point,Vf,Calibrage); \
Eblock \
ATes \
Bblock \
Test(TEST_MASQUE_ACTIF(X,Y,MASQUER_STORE)) \
Bblock \
EGAL(IMAGE(imageR,X,Y) \
,valeur \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define storeC_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CAST_CHAR(valeur),imageR,X,Y); \
/* La procedure 'CAST_CHAR(...)' a remplace un 'CAST(genere_CHAR,...)' le 20090331101826. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define storeIB_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_vrai_Int_de_base(valeur),imageR,X,Y); \
Eblock
#define AstoreIB_point(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_GENERAL(CASP_vrai_Int_de_base(valeur),albumR,X,Y,Z,NEUT); \
Eblock \
/* Introduit le 20100326182837... */
#define storeI_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_Int(valeur),imageR,X,Y); \
/* La procedure 'CASP_Int(...)' a remplace un 'CASP(genere_Int,...)' le 20090331103710. */ \
Eblock
#define AstoreI_point(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_GENERAL(CASP_Int(valeur),albumR,X,Y,Z,NEUT); \
/* La procedure 'CASP_Int(...)' a remplace un 'CASP(genere_Int,...)' le 20090331103710. */ \
Eblock \
/* Introduit le 20050909143052... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " P O S I T I V E " : */
/* */
/*************************************************************************************************************************************/
#define storeUB_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_vrai_Positive_de_base(valeur),imageR,X,Y); \
Eblock
#define storeU_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_LPositive(valeur),imageR,X,Y); \
/* La procedure 'CASP_LPositive(...)' remplace un 'CASP(genere_posi,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define storeF_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_Float(valeur),imageR,X,Y); \
/* La procedure 'CASP_Float(...)' a remplace un 'CASP(genere_Float,...)' le 20090331103710. */ \
Eblock
#define AstoreF_point(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_GENERAL(CASP_Float(valeur),albumR,X,Y,Z,NEUT); \
/* La procedure 'CASP_Float(...)' a remplace un 'CASP(genere_Float,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define storeD_point(valeur,imageR,X,Y) \
Bblock \
storeQV_point(CASP_Double(valeur),imageR,X,Y); \
/* La procedure 'CASP_Double(...)' remplace un 'CASP(genere_Double,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " C O M P L E X E " S O U S */
/* L A F O R M E P A R T I E R E E L L E E T I M A G I N A I R E : */
/* */
/*************************************************************************************************************************************/
#define storeJ_point(valeur_complexe,imageR,X,Y) \
Bblock \
storeRJ_point(Reelle(valeur_complexe),imageR,X,Y); \
/* Rangement de la partie reelle du nombre complexe, */ \
storeIJ_point(Imaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie imaginaire. */ \
Eblock \
/* Rangement du nombre complexe. */
#define storeJ_point_valide(valeur_complexe,imageR,X,Y) \
Bblock \
Test(TEST_DANS_L_IMAGE(X,Y)) \
Bblock \
storeJ_point(valeur_complexe,imageR,X,Y); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Rangement du nombre complexe avec validation. On notera la programmation specifique de */ \
/* 'storeJ_point_valide(...)' qui ne suit pas le modele 'storeQ_point_valide(...)' a cause */ \
/* du fait que 'valeur_complexe' est une structure et non pas un "scalaire"... */
#define storeRJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,Reelle); \
Eblock \
/* Rangement de la partie reelle du nombre complexe. */
#define storeIJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,Imaginaire); \
Eblock \
/* Rangement de la partie imaginaire du nombre complexe. */
#define storeRJ_point_valide(valeur_flottante,imageR,X,Y) \
Bblock \
Test(TEST_DANS_L_IMAGE(X,Y)) \
Bblock \
storeRJ_point(valeur_flottante,imageR,X,Y); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Rangement de la partie reelle du nombre complexe avec validation (introduit le */
/* 20120526185135). */
#define storeIJ_point_valide(valeur_flottante,imageR,X,Y) \
Bblock \
Test(TEST_DANS_L_IMAGE(X,Y)) \
Bblock \
storeIJ_point(valeur_flottante,imageR,X,Y); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Rangement de la partie imaginaire du nombre complexe avec validation (introduit le */
/* 20120526185135). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " H Y P E R - C O M P L E X E " S O U S */
/* L A F O R M E P A R T I E R E E L L E E T I M A G I N A I R E : */
/* */
/*************************************************************************************************************************************/
#define storeHJ_point(valeur_complexe,imageR,X,Y) \
Bblock \
storeRHJ_point(HReelle(valeur_complexe),imageR,X,Y); \
/* Rangement de la partie reelle du nombre complexe, */ \
storeIHJ_point(HImaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie imaginaire, */ \
storeJHJ_point(HJmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie jmaginaire, */ \
storeKHJ_point(HKmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie kmaginaire. */ \
Eblock \
/* Rangement du nombre hyper-complexe. */
#define storeRHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HReelle); \
Eblock \
/* Rangement de la partie reelle du nombre hyper-complexe. */
#define storeIHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HImaginaire); \
Eblock \
/* Rangement de la partie imaginaire du nombre hyper-complexe. */
#define storeJHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HJmaginaire); \
Eblock \
/* Rangement de la partie jmaginaire du nombre hyper-complexe. */
#define storeKHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HKmaginaire); \
Eblock \
/* Rangement de la partie kmaginaire du nombre hyper-complexe. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R A N G E M E N T D ' U N P O I N T " H Y P E R - H Y P E R - C O M P L E X E " S O U S */
/* L A F O R M E P A R T I E R E E L L E E T I M A G I N A I R E : */
/* */
/*************************************************************************************************************************************/
/* Toutes les definitions suivantes ont ete introduites le 20150227102109... */
#define storeHHJ_point(valeur_complexe,imageR,X,Y) \
Bblock \
storeRHHJ_point(HHReelle(valeur_complexe),imageR,X,Y); \
/* Rangement de la partie reelle du nombre hyper-hyper-complexe, */ \
storeIHHJ_point(HHImaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie imaginaire, */ \
storeJHHJ_point(HHJmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie jmaginaire, */ \
storeKHHJ_point(HHKmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie kmaginaire. */ \
storeSHHJ_point(HHSmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie smaginaire. */ \
storeTHHJ_point(HHTmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie tmaginaire. */ \
storeUHHJ_point(HHUmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie umaginaire. */ \
storeVHHJ_point(HHVmaginaire(valeur_complexe),imageR,X,Y); \
/* Puis, rangement de sa partie vmaginaire. */ \
Eblock \
/* Rangement du nombre hyper-hyper-complexe. */
#define storeRHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHReelle); \
Eblock \
/* Rangement de la partie reelle du nombre hyper-hyper-complexe. */
#define storeIHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHImaginaire); \
Eblock \
/* Rangement de la partie imaginaire du nombre hyper-hyper-complexe. */
#define storeJHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHJmaginaire); \
Eblock \
/* Rangement de la partie jmaginaire du nombre hyper-hyper-complexe. */
#define storeKHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHKmaginaire); \
Eblock \
/* Rangement de la partie kmaginaire du nombre hyper-hyper-complexe. */
#define storeSHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHSmaginaire); \
Eblock \
/* Rangement de la partie smaginaire du nombre hyper-hyper-complexe. */
#define storeTHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHTmaginaire); \
Eblock \
/* Rangement de la partie tmaginaire du nombre hyper-hyper-complexe. */
#define storeUHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHUmaginaire); \
Eblock \
/* Rangement de la partie umaginaire du nombre hyper-hyper-complexe. */
#define storeVHHJ_point(valeur_flottante,imageR,X,Y) \
Bblock \
storeQ_point_GENERAL(valeur_flottante,imageR,X,Y,loadX_point,Vf,Calibrage,HHVmaginaire); \
Eblock \
/* Rangement de la partie vmaginaire du nombre hyper-hyper-complexe. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define storeQ_point_valide(valeur,imageR,X,Y,loadX_point,Vf,Calibrage) \
Bblock \
Test(TEST_DANS_L_IMAGE(X,Y)) \
Bblock \
storeQ_point(valeur,imageR,X,Y,loadX_point,Vf,Calibrage); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define AstoreQ_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
Test(TEST_DANS_L_ALBUM(X,Y,Z)) \
Bblock \
AstoreQ_point_GENERAL(valeur,albumR,X,Y,Z,NEUT); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
#if ( (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# TestADef BUG_SYSTEME_C_complexite_01 \
/* Le compilateur 'cc' ne supporte pas des expressions trop complexes, telles celles qui */ \
/* sont le resultat de l'expansion de la procedure 'TRACE_POINT_3D' contenue dans le */ \
/* fichier '$xiii/montagnes$FON' ; le message suivant sort alors : */ \
/* */ \
/* 1-cas de 'SYSTEME_NWS3000_NEWSOS' : */ \
/* */ \
/* "Fatal error in: /usr/lib/cmplrs/cc/ugen Trace/BPT trap" */ \
/* */ \
/* et ceci est la seule solution que j'ai trouve... */ \
/* */ \
/* 2-cas de 'SYSTEME_SG' : */ \
/* */ \
/* le compilateur 'cc' ne supporte pas des expressions trop complexes, telles celles qui */ \
/* sont le resultat de l'expansion de la procedure 'TRACE_POINT_3D' contenue dans le */ \
/* fichier '$xiii/montagnes$FON' : le module 'usr/lib/ugen' fait alors un "core"... */ \
/* */
#Aif ( (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#Eif ( (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#if ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
# define store_point_valide(valeur,imageR,X,Y,Vf) \
Bblock \
storeQ_point_valide(GENP(valeur),imageR,X,Y,load_point,Vf,Ncalibrage); \
Eblock
# define Astore_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_valide(GENP(valeur),albumR,X,Y,Z); \
Eblock
#Aif ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
# define store_point_valide(valeur,imageR,X,Y,Vf) \
Bblock \
DEFV(genere_p,INIT(Gvaleur,GENP(valeur))); \
/* Cet intermediaire permet d'alleger le travail du compilateur... */ \
storeQ_point_valide(Gvaleur,imageR,X,Y,load_point,Vf,Ncalibrage); \
Eblock
# define Astore_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
DEFV(genere_p,INIT(Gvaleur,GENP(valeur))); \
/* Cet intermediaire permet d'alleger le travail du compilateur... */ \
AstoreQ_point_valide(Gvaleur,albumR,X,Y,Z); \
Eblock
#Eif ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
#define store_point_valide_simplifie(valeur,imageR,X,Y) \
Bblock \
store_point_valide(valeur,imageR,X,Y,FVARIABLE); \
Eblock \
/* Introduit le 20131231164141 afin que cette procedure possede le meme nombre d'arguments */ \
/* que les autres (l'argument 'Vf' y est donc implicite et vaut 'FVARIABLE'...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " C H A R " / " I N T " / " F L O A T " : */
/* */
/* */
/* Nota : */
/* */
/* Pour les "store" de types differents */
/* de 'genere_p', on ne peut appliquer la */
/* fonction 'Vf', car en effet le type de */
/* ses arguments est variable, alors que */
/* dans son corps, il est fixe... */
/* */
/*************************************************************************************************************************************/
#define storeQV_point_valide(valeur,imageR,X,Y) \
Bblock \
Test(TEST_DANS_L_IMAGE(X,Y)) \
Bblock \
storeQV_point(valeur,imageR,X,Y); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define storeC_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CAST_CHAR(valeur),imageR,X,Y); \
/* La procedure 'CAST_CHAR(...)' a remplace un 'CAST(genere_CHAR,...)' le 20090331101826. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define storeIB_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_vrai_Int_de_base(valeur),imageR,X,Y); \
Eblock
#define AstoreIB_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_valide(CASP_vrai_Int_de_base(valeur),albumR,X,Y,Z); \
Eblock \
/* Introduit le 20100326182837... */
#define storeI_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_Int(valeur),imageR,X,Y); \
/* La procedure 'CASP_Int(...)' a remplace un 'CASP(genere_Int,...)' le 20090331103710. */ \
Eblock
#define AstoreI_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_valide(CASP_Int(valeur),albumR,X,Y,Z); \
/* La procedure 'CASP_Int(...)' a remplace un 'CASP(genere_Int,...)' le 20090331103710. */ \
Eblock \
/* Introduit le 20050909144029... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " P O S I T I V E " : */
/* */
/*************************************************************************************************************************************/
#define storeUB_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_vrai_Positive_de_base(valeur),imageR,X,Y); \
Eblock
#define storeU_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_LPositive(valeur),imageR,X,Y); \
/* La procedure 'CASP_LPositive(...)' remplace un 'CASP(genere_posi,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define storeF_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_Float(valeur),imageR,X,Y); \
/* La procedure 'CASP_Float(...)' a remplace un 'CASP(genere_Float,...)' le 20090331103710. */ \
Eblock
#define AstoreF_point_valide(valeur,albumR,X,Y,Z) \
Bblock \
AstoreQ_point_valide(CASP_Float(valeur),albumR,X,Y,Z); \
/* La procedure 'CASP_Float(...)' a remplace un 'CASP(genere_Float,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L I D A T I O N P U I S R A N G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define storeD_point_valide(valeur,imageR,X,Y) \
Bblock \
storeQV_point_valide(CASP_Double(valeur),imageR,X,Y); \
/* La procedure 'CASP_Double(...)' remplace un 'CASP(genere_Double,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T Q U E L C O N Q U E : */
/* */
/*************************************************************************************************************************************/
#define storeQ_point_modulo(valeur,imageR,X,Y,loadX_point,Vf,Calibrage) \
Bblock \
storeQ_point(valeur,imageR,MODX(X),MODY(Y),loadX_point,Vf,Calibrage); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
#if ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
# define store_point_modulo(valeur,imageR,X,Y,Vf) \
Bblock \
storeQ_point_modulo(GENP(valeur),imageR,X,Y,load_point,Vf,Ncalibrage); \
Eblock
#Aif ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
# define store_point_modulo(valeur,imageR,X,Y,Vf) \
Bblock \
DEFV(genere_p,INIT(Gvaleur,GENP(valeur))); \
/* Cet intermediaire permet d'alleger le travail du compilateur... */ \
storeQ_point_modulo(Gvaleur,imageR,X,Y,load_point,Vf,Ncalibrage); \
Eblock
#Eif ( (! defined(BUG_SYSTEME_C_complexite_01)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " C H A R " / " I N T " / " F L O A T " : */
/* */
/* */
/* Nota : */
/* */
/* Pour les "store" de types differents */
/* de 'genere_p', on ne peut appliquer la */
/* fonction 'Vf', car en effet le type de */
/* ses arguments est variable, alors que */
/* dans son corps, il est fixe... */
/* */
/*************************************************************************************************************************************/
#define storeQV_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point(valeur,imageR,MODX(X),MODY(Y)); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " C H A R " : */
/* */
/*************************************************************************************************************************************/
#define storeC_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CAST_CHAR(valeur),imageR,X,Y); \
/* La procedure 'CAST_CHAR(...)' a remplace un 'CAST(genere_CHAR,...)' le 20090331101826. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " I N T " : */
/* */
/*************************************************************************************************************************************/
#define storeIB_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_vrai_Int_de_base(valeur),imageR,X,Y); \
Eblock
#define storeI_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_Int(valeur),imageR,X,Y); \
/* La procedure 'CASP_Int(...)' a remplace un 'CASP(genere_Int,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " P O S I T I V E " : */
/* */
/*************************************************************************************************************************************/
#define storeUB_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_vrai_Positive_de_base(valeur),imageR,X,Y); \
Eblock
#define storeU_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_LPositive(valeur),imageR,X,Y); \
/* La procedure 'CASP_LPositive(...)' remplace un 'CASP(genere_posi,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define storeF_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_Float(valeur),imageR,X,Y); \
/* La procedure 'CASP_Float(...)' a remplace un 'CASP(genere_Float,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O D U L O P U I S R A N G E M E N T D ' U N P O I N T " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
#define storeD_point_modulo(valeur,imageR,X,Y) \
Bblock \
storeQV_point_modulo(CASP_Double(valeur),imageR,X,Y); \
/* La procedure 'CASP_Double(...)' remplace un 'CASP(genere_Double,...)' le 20090331103710. */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L E U R A B S O L U E D ' U N P O I N T : */
/* */
/*************************************************************************************************************************************/
#define PABS(X,Y,imageA,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(VABS(niveau_imageA) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M P L E M E N T A T I O N D ' U N P O I N T : */
/* */
/*************************************************************************************************************************************/
#define PCOMP(X,Y,imageA,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(VCOMP(niveau_imageA) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A D D I T I O N D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PADD(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(GENP(TRNP(VADD(niveau_imageA1,niveau_imageA2))) \
,imageR,X,Y,FVARIABLE \
); \
Eblock \
/* ATTENTION, avant l'introduction du 'TRNP(...)', il y avait : */ \
/* */ \
/* store_point(NIVA(VADD(NIVR(load_point(imageA1,X,Y)) \ */ \
/* ,NIVR(load_point(imageA2,X,Y)) \ */ \
/* ) \ */ \
/* ) \ */ \
/* ,imageR,X,Y,FVARIABLE \ */ \
/* ); \ */ \
/* */ \
/* mais dans le but d'alleger le travail des compilateurs, deux variables intermediaires */ \
/* ont ete introduites... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R P O L A T I O N E N T R E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PINTER(X,Y,alpha,imageA1,beta,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(GENP(TRNP(VADD(NIVA(VMULF(alpha,NIVR(niveau_imageA1))) \
,NIVA(VMULF(beta,NIVR(niveau_imageA2))) \
) \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock \
/* ATTENTION, avant l'introduction du 'TRNP(...)', il y avait : */ \
/* */ \
/* store_point(NIVA(VADD(VMULF(alpha,NIVR(load_point(imageA1,X,Y))) \ */ \
/* ,VMULF(beta,NIVR(load_point(imageA2,X,Y))) \ */ \
/* ) \ */ \
/* ) \ */ \
/* ,imageR,X,Y,FVARIABLE \ */ \
/* ); \ */ \
/* */ \
/* mais dans le but d'alleger le travail des compilateurs, deux variables intermediaires */ \
/* ont ete introduites... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N C R E M E N T A T I O N D ' U N P O I N T : */
/* */
/*************************************************************************************************************************************/
#define PINC(X,Y,imageA,increment,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(VADD(niveau_imageA,NIVA(increment)) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S O U S T R A C T I O N D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PSUB(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VSUB(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L I C A T I O N D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PMUL(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(NIVA(VDIV(VMUL(FLOT(NIVR(niveau_imageA1)) \
,FLOT(NIVR(niveau_imageA2)) \
) \
,FLOT(NIVR(BLANC)) \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L I C A T I O N D E D E U X P O I N T S A V E C A R R O N D I : */
/* */
/*************************************************************************************************************************************/
#define PMULA(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(NIVA(ARRI(VDIV(VMUL(FLOT(NIVR(niveau_imageA1)) \
,FLOT(NIVR(niveau_imageA2)) \
) \
,FLOT(NIVR(BLANC)) \
) \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L I C A T I O N D ' U N P O I N T P A R U N F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
#define PMULF(X,Y,facteur,imageA,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(TRNF(VMULF(facteur \
,NIVR(niveau_imageA) \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O R M E L I N E A I R E F L O T T A N T E S U R U N P O I N T : */
/* */
/*************************************************************************************************************************************/
#define PAXPB(X,Y,facteur,translation,imageA,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(TRNF(AXPB(facteur \
,FLOT(NIVR(niveau_imageA)) \
,translation \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I V I S I O N D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PDIV(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
/* ATTENTION, jusqu'au 20190927170834, ces deux definitions etaient avant le 'Bblock', */ \
/* mais il est evident qu'il s'agit-la d'une erreur... */ \
\
store_point(NIVA(VDIV(FLOT(NIVR(niveau_imageA1)) \
,FLOT(NIVR(niveau_imageA2)) \
) \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A X I M U M D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PMAX(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VMAX(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M I N I M U M D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PMIN(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VMIN(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " O U " E X C L U S I F F L O U D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#define PMINMAX(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VMINMAX(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
#define PMAXMIN(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VMAXMIN(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock \
/* Introduit le 20061023092103 par "symetrie" avec 'PMINMAX(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N V E R S I O N D ' U N P O I N T : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define PINVERT(X,Y,imageA,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA,load_point(imageA,X,Y))); \
\
store_point(VINVERT(niveau_imageA) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' O R ' D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define POR(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VOR(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' A N D ' D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define PAND(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VAND(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* ' E O R ' D E D E U X P O I N T S : */
/* */
/*************************************************************************************************************************************/
#if ((Format_p==Format_char)||(Format_p==Format_int))
# define PEOR(X,Y,imageA1,imageA2,imageR) \
Bblock \
DEFV(genere_p,INIT(niveau_imageA1,load_point(imageA1,X,Y))); \
DEFV(genere_p,INIT(niveau_imageA2,load_point(imageA2,X,Y))); \
\
store_point(VEOR(niveau_imageA1 \
,niveau_imageA2 \
) \
,imageR,X,Y,FVARIABLE \
); \
Eblock
#Aif ((Format_p==Format_char)||(Format_p==Format_int))
#Eif ((Format_p==Format_char)||(Format_p==Format_int))
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' A C C E S C O N T I N U A U N E I M A G E F L O T T A N T E : */
/* */
/*************************************************************************************************************************************/
#define loadF_storeF_point_continu_lineaire_cubique_donnees_1(Xf,Yf) \
DEFV(Int,INIT(X_local,UNDEF)); \
/* Definition de l'abscisse decrivant l'axe 'OX', */ \
DEFV(Int,INIT(Y_local,UNDEF)); \
/* Definition de l'ordonnee decrivant l'axe 'OY'. */ \
DEFV(pointF_2D,barycentre); \
/* Pour calculer les coordonnees barycentriques d'un point dans une maille. */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=0,v=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+1,v=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=0,v=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+1,v=+1). */
#define loadF_storeF_point_continu_lineaire_cubique_donnees_2 \
DEFV(genere_Float,INIT(fonction___au_point_uUv0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=U,v=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUv1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=U,v=+1). */
#define loadF_storeF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvV,image,Xf,Yf) \
Bblock \
EGAL(X_local,INTX(Xf)); \
/* Definition de l'abscisse entiere decrivant l'axe 'OX', */ \
EGAL(Y_local,INTY(Yf)); \
/* Definition de l'ordonnee entiere decrivant l'axe 'OY'. */ \
\
INITIALISATION_POINT_2D(barycentre \
,DIVI(SOUS(Xf,FLOT(X_local)) \
,FLOT(pasX) \
) \
,DIVI(SOUS(Yf,FLOT(Y_local)) \
,FLOT(pasY) \
) \
); \
\
Test(IFEXff(ASD1(barycentre,x),COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)) \
/* Jusqu'au 20060515102100, c'etait 'NINCff(...)' qui etait utilisee ci-dessus, mais */ \
/* dans le cas present 'IFEXff(...)' peut etre utilisee sans probleme... */ \
Bblock \
PRINT_ERREUR("la coordonnee barycentrique 'x' est hors [0,1]"); \
CAL1(Prer3("elle vaut %g (Xf=%g,X=%d)\n",ASD1(barycentre,x),Xf,X)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEXff(ASD1(barycentre,y),COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)) \
/* Jusqu'au 20060515102100, c'etait 'NINCff(...)' qui etait utilisee ci-dessus, mais */ \
/* dans le cas present 'IFEXff(...)' peut etre utilisee sans probleme... */ \
Bblock \
PRINT_ERREUR("la coordonnee barycentrique 'y' est hors [0,1]"); \
CAL1(Prer3("elle vaut %g (Yf=%g,Y=%d)\n",ASD1(barycentre,y),Yf,Y)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
/* Calcul des coordonnees barycentriques (u,v) alias (ASD1(barycentre,x),ASD1(barycentre,y)) */ \
/* du point {X,Y} courant par rapport a la maille courante (pasX,pasY). */ \
Eblock
#define loadF_storeF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvV,image,Xf,Yf,load,store) \
Bblock \
EGAL(fonction___au_point_u0v0,load(image,NEUT(NEUT(X_local)),NEUT(NEUT(Y_local)))); \
/* Valeur de la fonction au noeud (u=0,v=0), */ \
EGAL(fonction___au_point_u1v0,load(image,NEUT(SUCX(X_local)),NEUT(NEUT(Y_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=0), */ \
EGAL(fonction___au_point_u0v1,load(image,NEUT(NEUT(X_local)),NEUT(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=0,v=+1), */ \
EGAL(fonction___au_point_u1v1,load(image,NEUT(SUCX(X_local)),NEUT(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=+1). */ \
Eblock
#define Gload_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf,load,store,type,cast) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf} E [Xmin,Xmax]x[Ymin,Ymax] */ \
/* */ \
Bblock \
loadF_storeF_point_continu_lineaire_cubique_donnees_1(Xf,Yf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
loadF_storeF_point_continu_lineaire_cubique_donnees_2; \
/* Donnees communes 2 aux interpolations lineaire et cubique. */ \
loadF_storeF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvV,image,Xf,Yf); \
loadF_storeF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvV \
,image \
,INTX(Xf),INTY(Yf) \
,load,store \
); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_uUv0 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v0 \
,fonction___au_point_u1v0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v1 \
,fonction___au_point_u1v1 \
,ASD1(barycentre,x) \
) \
); \
/* Calcul de la valeur de la fonction sur les aretes horizontales du carre de base... */ \
EGAL(fonction___au_point_uUvV \
,cast(INTERPOLATION_LINEAIRE(fonction___au_point_uUv0 \
,fonction___au_point_uUv1 \
,ASD1(barycentre,y) \
) \
) \
); \
Eblock \
/* Acces continu lineaire a une image flottante (introduit le 20131230111749). */
#define load_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf) \
Bblock \
Gload_point_continu_lineaire(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,load_point_valide,store_point_valide_simplifie \
,genere_p \
,GENP \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define loadF_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf) \
Bblock \
Gload_point_continu_lineaire(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,loadF_point_valide,storeF_point_valide \
,genere_Float \
,NEUT \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define Gload_point_continu_cubique(fonction___au_point_uUvV,image,Xf,Yf,load,store,type,cast) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf} E [Xmin,Xmax]x[Ymin,Ymax] */ \
/* */ \
Bblock \
loadF_storeF_point_continu_lineaire_cubique_donnees_1(Xf,Yf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
\
DEFV(genere_Float,INIT(fonction___au_point_u9v0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=-1,v=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+2,v=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u9v1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=-1,v=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+2,v=+1). */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=0,v=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+1,v=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=0,v=+2), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction au noeud (u=+1,v=+2). */ \
\
loadF_storeF_point_continu_lineaire_cubique_donnees_2; \
/* Donnees communes 2 aux interpolations lineaire et cubique. */ \
\
DEFV(Float,INIT(derivee_Du_au_noeud_u0v0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction au noeud (u=0,v=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction au noeud (u=+1,v=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u0v1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction au noeud (u=0,v=+1), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction au noeud (u=+1,v=+1). */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au noeud (u=0,v=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au noeud (u=+1,v=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au noeud (u=0,v=+1), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au noeud (u=+1,v=+1). */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au point (u=U,v=0), */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction au point (u=U,v=+1). */ \
\
loadF_storeF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvV,image,Xf,Yf); \
loadF_storeF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvV \
,image \
,INTX(Xf),INTY(Yf) \
,load,store \
); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_u9v0,load(image,NEUT(PREX(X_local)),NEUT(NEUT(Y_local)))); \
/* Valeur de la fonction au noeud (u=-1,v=0), */ \
EGAL(fonction___au_point_u2v0,load(image,SUCX(SUCX(X_local)),NEUT(NEUT(Y_local)))); \
/* Valeur de la fonction au noeud (u=+2,v=0), */ \
EGAL(fonction___au_point_u9v1,load(image,NEUT(PREX(X_local)),NEUT(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=-1,v=+1), */ \
EGAL(fonction___au_point_u2v1,load(image,SUCX(SUCX(X_local)),NEUT(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=+2,v=+1). */ \
EGAL(fonction___au_point_u0v9,load(image,NEUT(NEUT(X_local)),NEUT(PREY(Y_local)))); \
/* Valeur de la fonction au noeud (u=0,v=-1), */ \
EGAL(fonction___au_point_u1v9,load(image,NEUT(SUCX(X_local)),NEUT(PREY(Y_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=-1), */ \
EGAL(fonction___au_point_u0v2,load(image,NEUT(NEUT(X_local)),SUCY(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=0,v=+2), */ \
EGAL(fonction___au_point_u1v2,load(image,NEUT(SUCX(X_local)),SUCY(SUCY(Y_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=+2). */ \
EGAL(derivee_Du_au_noeud_u0v0 \
,DERIVATION_PARTIELLE(fonction___au_point_u9v0 \
,fonction___au_point_u1v0 \
,DOUB(pasX) \
) \
); \
EGAL(derivee_Du_au_noeud_u1v0 \
,DERIVATION_PARTIELLE(fonction___au_point_u0v0 \
,fonction___au_point_u2v0 \
,DOUB(pasX) \
) \
); \
EGAL(derivee_Du_au_noeud_u1v1 \
,DERIVATION_PARTIELLE(fonction___au_point_u0v1 \
,fonction___au_point_u2v1 \
,DOUB(pasX) \
) \
); \
EGAL(derivee_Du_au_noeud_u0v1 \
,DERIVATION_PARTIELLE(fonction___au_point_u9v1 \
,fonction___au_point_u1v1 \
,DOUB(pasX) \
) \
); \
EGAL(derivee_Dv_au_noeud_u0v0 \
,DERIVATION_PARTIELLE(fonction___au_point_u0v9 \
,fonction___au_point_u0v1 \
,DOUB(pasY) \
) \
); \
EGAL(derivee_Dv_au_noeud_u1v0 \
,DERIVATION_PARTIELLE(fonction___au_point_u1v9 \
,fonction___au_point_u1v1 \
,DOUB(pasY) \
) \
); \
EGAL(derivee_Dv_au_noeud_u1v1 \
,DERIVATION_PARTIELLE(fonction___au_point_u1v0 \
,fonction___au_point_u1v2 \
,DOUB(pasY) \
) \
); \
EGAL(derivee_Dv_au_noeud_u0v1 \
,DERIVATION_PARTIELLE(fonction___au_point_u0v0 \
,fonction___au_point_u0v2 \
,DOUB(pasY) \
) \
); \
/* Calcul des derivees partielles en 'u' et 'v' aux noeuds du carre de base par des */ \
/* differences finies a l'aide des differentes valeurs aux noeuds du maillage... */ \
EGAL(derivee_Dv_au_point_uUv0 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v0,derivee_Dv_au_noeud_u1v0,ASD1(barycentre,x)) \
); \
EGAL(derivee_Dv_au_point_uUv1 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v1,derivee_Dv_au_noeud_u1v1,ASD1(barycentre,x)) \
); \
/* Calcul des derivees partielles en 'u' et 'v' sur les aretes horizontales du carre de */ \
/* base par des interpolations lineaires a partir des sommets voisins (on notera que l'on */ \
/* ne peut utiliser d'interpolation cubique, puisqu'on ne connait pas encore les derivees). */ \
EGAL(fonction___au_point_uUv0 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v0 \
,derivee_Du_au_noeud_u0v0 \
,fonction___au_point_u1v0 \
,derivee_Du_au_noeud_u1v0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v1 \
,derivee_Du_au_noeud_u0v1 \
,fonction___au_point_u1v1 \
,derivee_Du_au_noeud_u1v1 \
,ASD1(barycentre,x) \
) \
); \
/* Calcul de la valeur de la fonction sur les aretes horizontales du carre de base... */ \
EGAL(fonction___au_point_uUvV \
,cast(INTERPOLATION_CUBIQUE(fonction___au_point_uUv0 \
,derivee_Dv_au_point_uUv0 \
,fonction___au_point_uUv1 \
,derivee_Dv_au_point_uUv1 \
,ASD1(barycentre,y) \
) \
) \
); \
Eblock \
/* Ordre des interpolations cubiques ('-1' est note '9') : */ \
/* */ \
/* */ \
/* v=2 - - - - - - - -0 2- - - - - - - -1 2- - - - - - - - */ \
/* | /| |\ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / [1] \ */ \
/* |/ | | \| */ \
/* v=1 9 1- - - - - - - -0 1---------U 1---1 1- - - - - - - -2 1 */ \
/* | | . | | */ \
/* | . | */ \
/* | | . | | */ \
/* | . | */ \
/* | | . | | */ \
/* | [2] U V | */ \
/* | | . | | */ \
/* | . | */ \
/* | | . | | */ \
/* v=0 9 0- - - -<- - - -0 0---------U 0---1 0- - - - - - - -2 0 */ \
/* |\ | | /| */ \
/* \ [1] / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \| |/ | */ \
/* v=-1 - - - - - - - -0 9- - - - - - - -1 9- - - - - - - - */ \
/* */ \
/* u=-1 u=0 u=1 u=2 */ \
/* */ \
/* */ \
/* v ^ */ \
/* | */ \
/* | */ \
/* |----> */ \
/* u */ \
/* */ \
/* */ \
/* Acces continu cubique a une image flottante... */
#define load_point_continu_cubique(fonction___au_point_uUvV,image,Xf,Yf) \
Bblock \
Gload_point_continu_cubique(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,load_point_valide,store_point_valide_simplifie \
,genere_p \
,GENP \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define loadF_point_continu_cubique(fonction___au_point_uUvV,image,Xf,Yf) \
Bblock \
Gload_point_continu_cubique(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,loadF_point_valide,storeF_point_valide \
,genere_Float \
,NEUT \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define load_point_continu(fonction___au_point_uUvV,image,Xf,Yf,interpolation_cubique) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf} E [Xmin,Xmax]x[Ymin,Ymax] */ \
/* */ \
Bblock \
Test(IL_FAUT(interpolation_cubique)) \
Bblock \
load_point_continu_cubique(fonction___au_point_uUvV,image,Xf,Yf); \
Eblock \
ATes \
Bblock \
load_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf); \
Eblock \
ETes \
Eblock \
/* Acces continu a une image "standard" (introduit le 20131231164141). */
#define loadF_point_continu(fonction___au_point_uUvV,image,Xf,Yf,interpolation_cubique) \
/* La possibilite de choisir l'interpolation a ete introduite le 20131230124002... */ \
/* */ \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf} E [Xmin,Xmax]x[Ymin,Ymax] */ \
/* */ \
Bblock \
Test(IL_FAUT(interpolation_cubique)) \
Bblock \
loadF_point_continu_cubique(fonction___au_point_uUvV,image,Xf,Yf); \
Eblock \
ATes \
Bblock \
loadF_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf); \
Eblock \
ETes \
Eblock \
/* Acces continu a une image flottante (introduit sous cette forme le 20131230111455). */
#define StoreLoad(niveau,image,X,Y,load,store,type,cast,ecraser) \
Bblock \
Test(IL_FAUT(ecraser)) \
Bblock \
store(cast(niveau),image,X,Y); \
Eblock \
ATes \
Bblock \
DEFV(type,INIT(niveau_anterieur,load(image,X,Y))); \
store(ADD2(cast(niveau),niveau_anterieur),image,X,Y); \
Eblock \
ETes \
Eblock \
/* Procedure introduite le 20140101094041 afin de permettre (en option) de ranger un */ \
/* niveau, mais sans perdre ce qui etait la anterieurement... */
#define Gstore_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf,load,store,type,cast,ecraser) \
/* L'argument 'fonction___au_point_uUvV' est donc le niveau a "etaler" sur les quatre */ \
/* sommets entiers du carre courant... */ \
/* */ \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf} E [Xmin,Xmax]x[Ymin,Ymax] */ \
/* */ \
Bblock \
loadF_storeF_point_continu_lineaire_cubique_donnees_1(Xf,Yf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
loadF_storeF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvV,image,Xf,Yf); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_u0v0,MUL3(fonction___au_point_uUvV,COMP(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)))); \
EGAL(fonction___au_point_u1v0,MUL3(fonction___au_point_uUvV,NEUT(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)))); \
EGAL(fonction___au_point_u0v1,MUL3(fonction___au_point_uUvV,COMP(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)))); \
EGAL(fonction___au_point_u1v1,MUL3(fonction___au_point_uUvV,NEUT(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)))); \
/* Calcul de la fonction aux quatre coins entiers du carre... */ \
\
StoreLoad(fonction___au_point_u0v0,image,NEUT(INTX(Xf)),NEUT(INTY(Yf)),load,store,type,cast,ecraser); \
StoreLoad(fonction___au_point_u1v0,image,SUCX(INTX(Xf)),NEUT(INTY(Yf)),load,store,type,cast,ecraser); \
StoreLoad(fonction___au_point_u0v1,image,NEUT(INTX(Xf)),SUCY(INTY(Yf)),load,store,type,cast,ecraser); \
StoreLoad(fonction___au_point_u1v1,image,SUCX(INTX(Xf)),SUCY(INTY(Yf)),load,store,type,cast,ecraser); \
/* Rangement des quatre coins entiers du carre par etalement de 'fonction___au_point_uUvV'. */ \
Eblock \
/* Acces continu lineaire a une image flottante (introduit le 20131230111749). */ \
/* */ \
/* ATTENTION, on notera que les procedures 'Gstore_point_continu_lineaire(...)' et */ \
/* 'Gload_point_continu_lineaire(...)' ne sont pas "inverses l'une de l'auutre. En */ \
/* effet 'Gload_point_continu_lineaire(...)' procede a une interpolation lineaire entre les */ \
/* quatre sommets du carre courant ; le niveau 'fonction___au_point_uUvV' resultant */ \
/* est donc une COMBINAISON LINEAIRE des valeurs aux quatre sommets du carre. Alors qu'avec */ \
/* 'Gstore_point_continu_lineaire(...)' la SOMME des valeurs aux quatre sommets du carre */ \
/* est egale "directement" a 'fonction___au_point_uUvV'... */ \
/* */ \
/* Soit donc pour 'Gstore_point_continu_lineaire(...)' : */ \
/* */ \
/* uUvV --> (u0v0)+(u1v0)+(u0v1)+(u1v1) */ \
/* */ \
/* alors que pour 'Gload_point_continu_lineaire(...)' : */ \
/* */ \
/* uUvV <-- a.(u0v0)+b.(u1v0)+c.(u0v1)+d.(u1v1) */ \
/* */ \
/* ou {a,b,c,d} sont dans [0,1]. */
#define store_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf,ecraser) \
Bblock \
Gstore_point_continu_lineaire(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,load_point_valide,store_point_valide_simplifie \
,genere_p \
,GENP \
,ecraser \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define storeF_point_continu_lineaire(fonction___au_point_uUvV,image,Xf,Yf,ecraser) \
Bblock \
Gstore_point_continu_lineaire(fonction___au_point_uUvV \
,image \
,Xf,Yf \
,loadF_point_valide,storeF_point_valide \
,genere_Float \
,NEUT \
,ecraser \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' A C C E S C O N T I N U A U N A L B U M F L O T T A N T : */
/* */
/*************************************************************************************************************************************/
#define AloadF_AstoreF_point_continu_lineaire_cubique_donnees_1(Xf,Yf,Zf) \
DEFV(Int,INIT(X_local,UNDEF)); \
/* Definition de l'abscisse decrivant l'axe 'OX', */ \
DEFV(Int,INIT(Y_local,UNDEF)); \
/* Definition de l'ordonnee decrivant l'axe 'OY'. */ \
DEFV(Int,INIT(Z_local,UNDEF)); \
/* Definition de l'ordonnee decrivant l'axe 'OZ'. */ \
DEFV(pointF_3D,barycentre); \
/* Pour calculer les coordonnees barycentriques d'un point dans une maille. */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v0w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v0w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v1w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v1w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v0w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v0w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v1w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v1w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=+1). */
#define AloadF_AstoreF_point_continu_lineaire_cubique_donnees_2 \
DEFV(genere_Float,INIT(fonction___au_point_uUv0w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=0,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUv1w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=+1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUv0w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=0,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUv1w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=+1,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUvVw0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=V,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_uUvVw1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=U,v=V,w=+1). */
#define AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvVwW,album,Xf,Yf,Zf) \
Bblock \
EGAL(X_local,INTX(Xf)); \
/* Definition de l'abscisse entiere decrivant l'axe 'OX', */ \
EGAL(Y_local,INTY(Yf)); \
/* Definition de l'ordonnee entiere decrivant l'axe 'OY'. */ \
EGAL(Z_local,INTZ(Zf)); \
/* Definition de l'ordonnee entiere decrivant l'axe 'OZ'. */ \
\
INITIALISATION_POINT_3D(barycentre \
,DIVI(SOUS(Xf,FLOT(X_local)) \
,FLOT(pasX) \
) \
,DIVI(SOUS(Yf,FLOT(Y_local)) \
,FLOT(pasY) \
) \
,DIVI(SOUS(Zf,FLOT(Z_local)) \
,FLOT(pasZ) \
) \
); \
\
Test(IFEXff(ASD1(barycentre,x),COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)) \
Bblock \
PRINT_ERREUR("la coordonnee barycentrique 'x' est hors [0,1]"); \
CAL1(Prer3("elle vaut %g (Xf=%g,X=%d)\n",ASD1(barycentre,x),Xf,X)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEXff(ASD1(barycentre,y),COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)) \
Bblock \
PRINT_ERREUR("la coordonnee barycentrique 'y' est hors [0,1]"); \
CAL1(Prer3("elle vaut %g (Yf=%g,Y=%d)\n",ASD1(barycentre,y),Yf,Y)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEXff(ASD1(barycentre,z),COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)) \
Bblock \
PRINT_ERREUR("la coordonnee barycentrique 'z' est hors [0,1]"); \
CAL1(Prer3("elle vaut %g (Zf=%g,Z=%d)\n",ASD1(barycentre,z),Zf,Z)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
/* Calcul des coordonnees barycentriques (u,v,w) du point {X,Y,Z}... */ \
Eblock
#define AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,Aload,Astore) \
Bblock \
EGAL(fonction___au_point_u0v0w0,Aload(album,NEUT(NEUT(X_local)),NEUT(NEUT(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction au noeud (u=0,v=0,w=0), */ \
EGAL(fonction___au_point_u1v0w0,Aload(album,NEUT(SUCX(X_local)),NEUT(NEUT(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=0,w=0), */ \
EGAL(fonction___au_point_u0v1w0,Aload(album,NEUT(NEUT(X_local)),NEUT(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction au noeud (u=0,v=+1,w=0), */ \
EGAL(fonction___au_point_u1v1w0,Aload(album,NEUT(SUCX(X_local)),NEUT(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=+1,w=0). */ \
EGAL(fonction___au_point_u0v0w1,Aload(album,NEUT(NEUT(X_local)),NEUT(NEUT(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction au noeud (u=0,v=0,w=1), */ \
EGAL(fonction___au_point_u1v0w1,Aload(album,NEUT(SUCX(X_local)),NEUT(NEUT(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=0,w=1), */ \
EGAL(fonction___au_point_u0v1w1,Aload(album,NEUT(NEUT(X_local)),NEUT(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction au noeud (u=0,v=+1,w=1), */ \
EGAL(fonction___au_point_u1v1w1,Aload(album,NEUT(SUCX(X_local)),NEUT(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction au noeud (u=+1,v=+1,w=1). */ \
Eblock
#define GAload_point_continu_lineaire(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,Aload,Astore,type,cast) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf,Zf} E [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] */ \
/* */ \
Bblock \
AloadF_AstoreF_point_continu_lineaire_cubique_donnees_1(Xf,Yf,Zf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
AloadF_AstoreF_point_continu_lineaire_cubique_donnees_2; \
/* Donnees communes 2 aux interpolations lineaire et cubique. */ \
AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvVwW \
,album \
,INTX(Xf),INTY(Yf),INTZ(Zf) \
,Aload,Astore \
); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_uUv0w0 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v0w0 \
,fonction___au_point_u1v0w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1w0 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v1w0 \
,fonction___au_point_u1v1w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv0w1 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v0w1 \
,fonction___au_point_u1v0w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1w1 \
,INTERPOLATION_LINEAIRE(fonction___au_point_u0v1w1 \
,fonction___au_point_u1v1w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUvVw0 \
,INTERPOLATION_LINEAIRE(fonction___au_point_uUv0w0 \
,fonction___au_point_uUv1w0 \
,ASD1(barycentre,y) \
) \
); \
EGAL(fonction___au_point_uUvVw1 \
,INTERPOLATION_LINEAIRE(fonction___au_point_uUv0w1 \
,fonction___au_point_uUv1w1 \
,ASD1(barycentre,y) \
) \
); \
/* Calcul de la valeur de la fonction sur les aretes horizontales du cube de base... */ \
EGAL(fonction___au_point_uUvVwW \
,cast(INTERPOLATION_LINEAIRE(fonction___au_point_uUvVw0 \
,fonction___au_point_uUvVw1 \
,ASD1(barycentre,z) \
) \
) \
); \
Eblock \
/* Acces continu lineaire a un album flottant (introduit le 20131231122301). */
#define Aload_point_continu_lineaire(fonction___au_point_uUvV,album,Xf,Yf,Zf) \
Bblock \
GAload_point_continu_lineaire(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,Aload_point_valide,Astore_point_valide \
,genere_p \
,GENP \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define AloadF_point_continu_lineaire(fonction___au_point_uUvV,album,Xf,Yf,Zf) \
Bblock \
GAload_point_continu_lineaire(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,AloadF_point_valide,AstoreF_point_valide \
,genere_Float \
,NEUT \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee,fonction_origine,fonction_extremite,pas_du_maillage) \
Bblock \
EGAL(derivee \
,DERIVATION_PARTIELLE(fonction_origine \
,fonction_extremite \
,DOUB(pas_du_maillage) \
) \
); \
Eblock
#define GAload_point_continu_cubique(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,Aload,Astore,type,cast) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf,Zf} E [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] */ \
/* */ \
Bblock \
AloadF_AstoreF_point_continu_lineaire_cubique_donnees_1(Xf,Yf,Zf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
\
DEFV(genere_Float,INIT(fonction___au_point_u9v0w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=0,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v0w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=0,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u9v1w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=+1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v1w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=+1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u9v0w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=0,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v0w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=0,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u9v1w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=+1,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u2v1w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=+1,w=+1). */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v9w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=-1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v9w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=-1,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v2w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+2,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v2w0,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+2,w=0), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v9w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=-1,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v9w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=-1,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v2w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+2,w=+1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v2w1,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+2,w=+1). */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v0w9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v0w9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v1w9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v1w9,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=-1), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v0w2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=+2), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v0w2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=+2), */ \
DEFV(genere_Float,INIT(fonction___au_point_u0v1w2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=+2), */ \
DEFV(genere_Float,INIT(fonction___au_point_u1v1w2,FLOT__NIVEAU_UNDEF)); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=+2). */ \
\
AloadF_AstoreF_point_continu_lineaire_cubique_donnees_2; \
/* Donnees communes 2 aux interpolations lineaire et cubique. */ \
\
DEFV(Float,INIT(derivee_Du_au_noeud_u0v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=0,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=+1,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u0v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=0,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=+1,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u0v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=0,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=+1,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u0v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=0,v=+1,w=+1), */ \
DEFV(Float,INIT(derivee_Du_au_noeud_u1v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'u' de la fonction aleatoire au noeud (u=+1,v=+1,w=+1). */ \
\
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=0,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=+1,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=0,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=+1,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=0,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=+1,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u0v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=0,v=+1,w=+1), */ \
DEFV(Float,INIT(derivee_Dv_au_noeud_u1v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au noeud (u=+1,v=+1,w=+1). */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au point (u=U,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au point (u=U,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au point (u=U,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dv_au_point_uUv1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'v' de la fonction aleatoire au point (u=U,v=+1,w=+1). */ \
\
DEFV(Float,INIT(derivee_Dw_au_noeud_u0v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=0,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u1v0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=+1,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u0v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=0,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u1v1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=+1,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u0v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=0,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u1v0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=+1,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u0v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=0,v=+1,w=+1), */ \
DEFV(Float,INIT(derivee_Dw_au_noeud_u1v1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au noeud (u=+1,v=+1,w=+1). */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUv0w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=0,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUv1w0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=+1,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUv0w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=0,w=+1), */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUv1w1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=+1,w=+1). */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUvVw0,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=V,w=0), */ \
DEFV(Float,INIT(derivee_Dw_au_point_uUvVw1,FLOT__UNDEF)); \
/* Valeur de la derivee partielle en 'w' de la fonction aleatoire au point (u=U,v=V,w=+1). */ \
\
AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_2(fonction___au_point_uUvVwW \
,album \
,INTX(Xf),INTY(Yf),INTZ(Zf) \
,Aload,Astore \
); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_u9v0w0,Aload(album,NEUT(PREX(X_local)),NEUT(NEUT(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=0,w=0), */ \
EGAL(fonction___au_point_u2v0w0,Aload(album,SUCX(SUCX(X_local)),NEUT(NEUT(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=0,w=0), */ \
EGAL(fonction___au_point_u9v1w0,Aload(album,NEUT(PREX(X_local)),NEUT(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=+1,w=0), */ \
EGAL(fonction___au_point_u2v1w0,Aload(album,SUCX(SUCX(X_local)),NEUT(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=+1,w=0), */ \
EGAL(fonction___au_point_u9v0w1,Aload(album,NEUT(PREX(X_local)),NEUT(NEUT(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=0,w=+1), */ \
EGAL(fonction___au_point_u2v0w1,Aload(album,SUCX(SUCX(X_local)),NEUT(NEUT(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=0,w=+1), */ \
EGAL(fonction___au_point_u9v1w1,Aload(album,NEUT(PREX(X_local)),NEUT(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=-1,v=+1,w=+1), */ \
EGAL(fonction___au_point_u2v1w1,Aload(album,SUCX(SUCX(X_local)),NEUT(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+2,v=+1,w=+1). */ \
EGAL(fonction___au_point_u0v9w0,Aload(album,NEUT(NEUT(X_local)),NEUT(PREY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=-1,w=0), */ \
EGAL(fonction___au_point_u1v9w0,Aload(album,NEUT(SUCX(X_local)),NEUT(PREY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=-1,w=0), */ \
EGAL(fonction___au_point_u0v2w0,Aload(album,NEUT(NEUT(X_local)),SUCY(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+2,w=0), */ \
EGAL(fonction___au_point_u1v2w0,Aload(album,NEUT(SUCX(X_local)),SUCY(SUCY(Y_local)),NEUT(NEUT(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+2,w=0), */ \
EGAL(fonction___au_point_u0v9w1,Aload(album,NEUT(NEUT(X_local)),NEUT(PREY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=-1,w=+1), */ \
EGAL(fonction___au_point_u1v9w1,Aload(album,NEUT(SUCX(X_local)),NEUT(PREY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=-1,w=+1), */ \
EGAL(fonction___au_point_u0v2w1,Aload(album,NEUT(NEUT(X_local)),SUCY(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+2,w=+1), */ \
EGAL(fonction___au_point_u1v2w1,Aload(album,NEUT(SUCX(X_local)),SUCY(SUCY(Y_local)),NEUT(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+2,w=+1). */ \
EGAL(fonction___au_point_u0v0w9,Aload(album,NEUT(NEUT(X_local)),NEUT(NEUT(Y_local)),NEUT(PREZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=-1), */ \
EGAL(fonction___au_point_u1v0w9,Aload(album,NEUT(SUCX(X_local)),NEUT(NEUT(Y_local)),NEUT(PREZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=-1), */ \
EGAL(fonction___au_point_u0v1w9,Aload(album,NEUT(NEUT(X_local)),NEUT(SUCY(Y_local)),NEUT(PREZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=-1), */ \
EGAL(fonction___au_point_u1v1w9,Aload(album,NEUT(SUCX(X_local)),NEUT(SUCY(Y_local)),NEUT(PREZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=-1), */ \
EGAL(fonction___au_point_u0v0w2,Aload(album,NEUT(NEUT(X_local)),NEUT(NEUT(Y_local)),SUCZ(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=0,w=+2), */ \
EGAL(fonction___au_point_u1v0w2,Aload(album,NEUT(SUCX(X_local)),NEUT(NEUT(Y_local)),SUCZ(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=0,w=+2), */ \
EGAL(fonction___au_point_u0v1w2,Aload(album,NEUT(NEUT(X_local)),NEUT(SUCY(Y_local)),SUCZ(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=0,v=+1,w=+2), */ \
EGAL(fonction___au_point_u1v1w2,Aload(album,NEUT(SUCX(X_local)),NEUT(SUCY(Y_local)),SUCZ(SUCZ(Z_local)))); \
/* Valeur de la fonction aleatoire au noeud (u=+1,v=+1,w=+2). */ \
\
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u0v0w0 \
,fonction___au_point_u9v0w0 \
,fonction___au_point_u1v0w0 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u1v0w0 \
,fonction___au_point_u0v0w0 \
,fonction___au_point_u2v0w0 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u1v1w0 \
,fonction___au_point_u0v1w0 \
,fonction___au_point_u2v1w0 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u0v1w0 \
,fonction___au_point_u9v1w0 \
,fonction___au_point_u1v1w0 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u0v0w1 \
,fonction___au_point_u9v0w1 \
,fonction___au_point_u1v0w1 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u1v0w1 \
,fonction___au_point_u0v0w1 \
,fonction___au_point_u2v0w1 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u1v1w1 \
,fonction___au_point_u0v1w1 \
,fonction___au_point_u2v1w1 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Du_au_noeud_u0v1w1 \
,fonction___au_point_u9v1w1 \
,fonction___au_point_u1v1w1 \
,pasX \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u0v0w0 \
,fonction___au_point_u0v9w0 \
,fonction___au_point_u0v1w0 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u1v0w0 \
,fonction___au_point_u1v9w0 \
,fonction___au_point_u1v1w0 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u1v1w0 \
,fonction___au_point_u1v0w0 \
,fonction___au_point_u1v2w0 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u0v1w0 \
,fonction___au_point_u0v0w0 \
,fonction___au_point_u0v2w0 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u0v0w1 \
,fonction___au_point_u0v9w1 \
,fonction___au_point_u0v1w1 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u1v0w1 \
,fonction___au_point_u1v9w1 \
,fonction___au_point_u1v1w1 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u1v1w1 \
,fonction___au_point_u1v0w1 \
,fonction___au_point_u1v2w1 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dv_au_noeud_u0v1w1 \
,fonction___au_point_u0v0w1 \
,fonction___au_point_u0v2w1 \
,pasY \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u0v0w0 \
,fonction___au_point_u0v0w9 \
,fonction___au_point_u0v0w1 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u1v0w0 \
,fonction___au_point_u1v0w9 \
,fonction___au_point_u1v0w1 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u1v1w0 \
,fonction___au_point_u1v1w9 \
,fonction___au_point_u1v1w1 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u0v1w0 \
,fonction___au_point_u0v1w9 \
,fonction___au_point_u0v1w1 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u0v0w1 \
,fonction___au_point_u0v0w0 \
,fonction___au_point_u0v0w2 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u1v0w1 \
,fonction___au_point_u1v0w0 \
,fonction___au_point_u1v0w2 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u1v1w1 \
,fonction___au_point_u1v1w0 \
,fonction___au_point_u1v1w2 \
,pasZ \
); \
CALCUL_DE_LA_DERIVEE_EN_UN_POINT(derivee_Dw_au_noeud_u0v1w1 \
,fonction___au_point_u0v1w0 \
,fonction___au_point_u0v1w2 \
,pasZ \
); \
/* Calcul des derivees partielles en 'u', 'v' et 'w' aux noeuds du cube de base par des */ \
/* differences finies a l'aide des differentes valeurs aux noeuds du maillage... */ \
\
EGAL(derivee_Dv_au_point_uUv0w0 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v0w0 \
,derivee_Dv_au_noeud_u1v0w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dv_au_point_uUv1w0 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v1w0 \
,derivee_Dv_au_noeud_u1v1w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dv_au_point_uUv0w1 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v0w1 \
,derivee_Dv_au_noeud_u1v0w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dv_au_point_uUv1w1 \
,INTERPOLATION_LINEAIRE(derivee_Dv_au_noeud_u0v1w1 \
,derivee_Dv_au_noeud_u1v1w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dw_au_point_uUv0w0 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_noeud_u0v0w0 \
,derivee_Dw_au_noeud_u1v0w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dw_au_point_uUv1w0 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_noeud_u0v1w0 \
,derivee_Dw_au_noeud_u1v1w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dw_au_point_uUv0w1 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_noeud_u0v0w1 \
,derivee_Dw_au_noeud_u1v0w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(derivee_Dw_au_point_uUv1w1 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_noeud_u0v1w1 \
,derivee_Dw_au_noeud_u1v1w1 \
,ASD1(barycentre,x) \
) \
); \
/* Calcul des derivees partielles en 'u', 'v' et 'w' sur des aretes horizontales du cube de */ \
/* base par des interpolations lineaires a partir des sommets voisins (on notera que l'on */ \
/* ne peut utiliser d'interpolation cubique, puisqu'on ne connait pas encore les derivees). */ \
EGAL(derivee_Dw_au_point_uUvVw0 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_point_uUv0w0 \
,derivee_Dw_au_point_uUv1w0 \
,ASD1(barycentre,y) \
) \
); \
EGAL(derivee_Dw_au_point_uUvVw1 \
,INTERPOLATION_LINEAIRE(derivee_Dw_au_point_uUv0w1 \
,derivee_Dw_au_point_uUv1w1 \
,ASD1(barycentre,y) \
) \
); \
/* Calcul des derivees partielles en 'u', 'v' et 'w' sur des segments verticaux du cube de */ \
/* base par des interpolations lineaires a partir des sommets voisins (on notera que l'on */ \
/* ne peut utiliser d'interpolation cubique, puisqu'on ne connait pas encore les derivees). */ \
\
EGAL(fonction___au_point_uUv0w0 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v0w0 \
,derivee_Du_au_noeud_u0v0w0 \
,fonction___au_point_u1v0w0 \
,derivee_Du_au_noeud_u1v0w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1w0 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v1w0 \
,derivee_Du_au_noeud_u0v1w0 \
,fonction___au_point_u1v1w0 \
,derivee_Du_au_noeud_u1v1w0 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv0w1 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v0w1 \
,derivee_Du_au_noeud_u0v0w1 \
,fonction___au_point_u1v0w1 \
,derivee_Du_au_noeud_u1v0w1 \
,ASD1(barycentre,x) \
) \
); \
EGAL(fonction___au_point_uUv1w1 \
,INTERPOLATION_CUBIQUE(fonction___au_point_u0v1w1 \
,derivee_Du_au_noeud_u0v1w1 \
,fonction___au_point_u1v1w1 \
,derivee_Du_au_noeud_u1v1w1 \
,ASD1(barycentre,x) \
) \
); \
/* Calcul de la valeur de la fonction sur des aretes horizontales du cube de base... */ \
EGAL(fonction___au_point_uUvVw0 \
,INTERPOLATION_CUBIQUE(fonction___au_point_uUv0w0 \
,derivee_Dv_au_point_uUv0w0 \
,fonction___au_point_uUv1w0 \
,derivee_Dv_au_point_uUv1w0 \
,ASD1(barycentre,y) \
) \
); \
EGAL(fonction___au_point_uUvVw1 \
,INTERPOLATION_CUBIQUE(fonction___au_point_uUv0w1 \
,derivee_Dv_au_point_uUv0w1 \
,fonction___au_point_uUv1w1 \
,derivee_Dv_au_point_uUv1w1 \
,ASD1(barycentre,y) \
) \
); \
/* Calcul de la valeur de la fonction sur des segments verticaux du cube de base... */ \
EGAL(fonction___au_point_uUvVwW \
,cast(INTERPOLATION_CUBIQUE(fonction___au_point_uUvVw0 \
,derivee_Dw_au_point_uUvVw0 \
,fonction___au_point_uUvVw1 \
,derivee_Dw_au_point_uUvVw1 \
,ASD1(barycentre,z) \
) \
) \
); \
/* Ordre des interpolations cubiques ('-1' est note '9') : */ \
/* */ \
/* */ \
/* v=1 012- - - - - - - -112 */ \
/* | (31) (30) | */ \
/* | | */ \
/* | | */ \
/* | | */ \
/* w=2 | | */ \
/* | | */ \
/* | | */ \
/* | | */ \
/* | (28) (29) | */ \
/* v=0 002- - - - - - - -102 */ \
/* */ \
/* u=0 u=1 */ \
/* */ \
/* */ \
/* v=2 - - - - - - - -021- - - - - - - -121- - - - - - - - */ \
/* | /| (26) (25) |\ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / \ */ \
/* | / | | \ | */ \
/* / [1] \ */ \
/* |/ | | \| */ \
/* v=1 911- - - - - - - -011---------U11---111- - - - - - - -211 */ \
/* | (27) | (07) .(06) | (24) | */ \
/* | . | */ \
/* | | . | | */ \
/* | . | */ \
/* w=1 | | . | | */ \
/* | [2] UV1 | --> UV1 */ \
/* | | . | | . */ \
/* | . | . */ \
/* | (20) | (04) .(05) | (23) | . */ \
/* v=0 901- - - - - - - -001---------U01---101- - - - - - - -201 . */ \
/* |\ | | /| . */ \
/* \ [1] / . */ \
/* | \ | | / | . */ \
/* \ / . */ \
/* | \ | | / | . */ \
/* \ / . */ \
/* | \ | | / | . */ \
/* \ / . */ \
/* | \| (21) (22) |/ | . */ \
/* v=-1 - - - - - - - -091- - - - - - - -191- - - - - - - - . */ \
/* . */ \
/* u=-1 u=0 u=1 u=2 . */ \
/* . */ \
/* . */ \
/* v=2 - - - - - - - -020- - - - - - - -120- - - - - - - - . */ \
/* | /| (18) (17) |\ | . */ \
/* / \ . */ \
/* | / | | \ | [3] UVW */ \
/* / \ . */ \
/* | / | | \ | . */ \
/* / \ . */ \
/* | / | | \ | . */ \
/* / [1] \ . */ \
/* |/ | | \| . */ \
/* v=1 910- - - - - - - -010---------U10---110- - - - - - - -210 . */ \
/* | (19) | (03) .(02) | (16) | . */ \
/* | . | . */ \
/* | | . | | . */ \
/* | . | . */ \
/* w=0 | | . | | . */ \
/* | [2] UV0 | --> UV0 */ \
/* | | . | | */ \
/* | . | */ \
/* | (12) | (00) .(01) | (15) | */ \
/* v=0 900- - - - - - - -000---------U00---100- - - - - - - -200 */ \
/* |\ | | /| */ \
/* \ [1] / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \ | | / | */ \
/* \ / */ \
/* | \| (13) (14) |/ | */ \
/* v=-1 - - - - - - - -090- - - - - - - -190- - - - - - - - */ \
/* */ \
/* u=-1 u=0 u=1 u=2 */ \
/* */ \
/* */ \
/* v=1 019- - - - - - - -119 */ \
/* | (11) (10) | */ \
/* | | */ \
/* | | */ \
/* | | */ \
/* w=-1 | | */ \
/* | | */ \
/* | | */ \
/* | | */ \
/* | (08) (09) | */ \
/* v=0 009- - - - - - - -109 */ \
/* */ \
/* u=0 u=1 */ \
/* */ \
/* */ \
/* v ^ w */ \
/* | / */ \
/* |/ */ \
/* O----> */ \
/* u */ \
/* */ \
/* (on trouve entre parentheses sous la forme 'mn' le numero d'acces a ce noeud de '00' */ \
/* -le premier traite- a '31' -le dernier-). */ \
Eblock \
/* Acces continu cubique a un album flottant... */
#define Aload_point_continu_cubique(fonction___au_point_uUvV,album,Xf,Yf,Zf) \
Bblock \
GAload_point_continu_cubique(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,Aload_point_valide,Astore_point_valide \
,genere_p \
,GENP \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define AloadF_point_continu_cubique(fonction___au_point_uUvV,album,Xf,Yf,Zf) \
Bblock \
GAload_point_continu_cubique(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,AloadF_point_valide,AstoreF_point_valide \
,genere_Float \
,NEUT \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define Aload_point_continu(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,interpolation_cubique) \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf,Zf} E [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] */ \
/* */ \
Bblock \
Test(IL_FAUT(interpolation_cubique)) \
Bblock \
Aload_point_continu_cubique(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
Eblock \
ATes \
Bblock \
Aload_point_continu_lineaire(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
Eblock \
ETes \
Eblock \
/* Acces continu a un album "standard" (introduit le 20131231164141). */
#define AloadF_point_continu(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,interpolation_cubique) \
/* La possibilite de choisir l'interpolation a ete introduite le 20131231122301... */ \
/* */ \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf,Zf} E [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] */ \
/* */ \
Bblock \
Test(IL_FAUT(interpolation_cubique)) \
Bblock \
AloadF_point_continu_cubique(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
Eblock \
ATes \
Bblock \
AloadF_point_continu_lineaire(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
Eblock \
ETes \
Eblock \
/* Acces continu a un album flottant (introduit sous cette forme le 20131231122301). */
#define AStoreLoad(niveau,album,X,Y,Z,Aload,Astore,type,cast,ecraser) \
Bblock \
Test(IL_FAUT(ecraser)) \
Bblock \
Astore(cast(niveau),album,X,Y,Z); \
Eblock \
ATes \
Bblock \
DEFV(type,INIT(niveau_anterieur,Aload(album,X,Y,Z))); \
Astore(ADD2(cast(niveau),niveau_anterieur),album,X,Y,Z); \
Eblock \
ETes \
Eblock \
/* Procedure introduite le 20140101094041 afin de permettre (en option) de ranger un */ \
/* niveau, mais sans perdre ce qui etait la anterieurement... */
#define GAstore_point_continu_lineaire(fonction___au_point_uUvVwW,album,Xf,Yf,Zf,Aload,Astore,type,cast,ecraser) \
/* L'argument 'fonction___au_point_uUvVwW' est donc le niveau a "etaler" sur les huit */ \
/* sommets entiers du cube courant... */ \
/* */ \
/* ATTENTION : */ \
/* */ \
/* {Xf,Yf,Zf} E [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] */ \
/* */ \
Bblock \
AloadF_AstoreF_point_continu_lineaire_cubique_donnees_1(Xf,Yf,Zf); \
/* Donnees communes 1 aux interpolations lineaire et cubique. */ \
AloadF_AstoreF_point_continu_lineaire_cubique_initialisation_1(fonction___au_point_uUvVwW,album,Xf,Yf,Zf); \
/* Initialisation de l'interpolation. */ \
\
EGAL(fonction___au_point_u0v0w0 \
,MUL4(fonction___au_point_uUvVwW,COMP(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)),COMP(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u1v0w0 \
,MUL4(fonction___au_point_uUvVwW,NEUT(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)),COMP(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u0v1w0 \
,MUL4(fonction___au_point_uUvVwW,COMP(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)),COMP(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u1v1w0 \
,MUL4(fonction___au_point_uUvVwW,NEUT(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)),COMP(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u0v0w1 \
,MUL4(fonction___au_point_uUvVwW,COMP(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)),NEUT(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u1v0w1 \
,MUL4(fonction___au_point_uUvVwW,NEUT(ASD1(barycentre,x)),COMP(ASD1(barycentre,y)),NEUT(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u0v1w1 \
,MUL4(fonction___au_point_uUvVwW,COMP(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)),NEUT(ASD1(barycentre,z))) \
); \
EGAL(fonction___au_point_u1v1w1 \
,MUL4(fonction___au_point_uUvVwW,NEUT(ASD1(barycentre,x)),NEUT(ASD1(barycentre,y)),NEUT(ASD1(barycentre,z))) \
); \
/* Calcul de la fonction aux huit coins entiers du cube... */ \
\
AStoreLoad(fonction___au_point_u0v0w0 \
,album \
,NEUT(INTX(Xf)),NEUT(INTY(Yf)),NEUT(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u1v0w0 \
,album \
,SUCX(INTX(Xf)),NEUT(INTY(Yf)),NEUT(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u0v1w0 \
,album \
,NEUT(INTX(Xf)),SUCY(INTY(Yf)),NEUT(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u1v1w0 \
,album \
,SUCX(INTX(Xf)),SUCY(INTY(Yf)),NEUT(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u0v0w1 \
,album \
,NEUT(INTX(Xf)),NEUT(INTY(Yf)),SUCZ(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u1v0w1 \
,album \
,SUCX(INTX(Xf)),NEUT(INTY(Yf)),SUCZ(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u0v1w1 \
,album \
,NEUT(INTX(Xf)),SUCY(INTY(Yf)),SUCZ(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
AStoreLoad(fonction___au_point_u1v1w1 \
,album,SUCX(INTX(Xf)),SUCY(INTY(Yf)),SUCZ(INTZ(Zf)) \
,Aload,Astore \
,type,cast \
,ecraser \
); \
/* Rangement des huit coins entiers du cube par etalement de 'fonction___au_point_uUvVwW'. */ \
Eblock \
/* Acces continu lineaire a un album flottant (introduit le 20131231122301). */ \
/* */ \
/* ATTENTION, on notera que les procedures 'GAstore_point_continu_lineaire(...)' et */ \
/* 'GAload_point_continu_lineaire(...)' ne sont pas "inverses l'une de l'auutre. En */ \
/* effet 'GAload_point_continu_lineaire(...)' procede a une interpolation lineaire entre les */ \
/* huit sommets du cube courant ; le niveau 'fonction___au_point_uUvV' resultant */ \
/* est donc une COMBINAISON LINEAIRE des valeurs aux huit sommets du cube. Alors qu'avec */ \
/* 'GAstore_point_continu_lineaire(...)' la SOMME des valeurs aux huit sommets du cube */ \
/* est egale "directement" a 'fonction___au_point_uUvV'... */ \
/* */ \
/* Soit donc pour 'GAstore_point_continu_lineaire(...)' : */ \
/* */ \
/* uUvVwW --> (u0v0w0)+(u1v0w0)+(u0v1w0)+(u1v1w0) */ \
/* +(u0v0w1)+(u1v0w1)+(u0v1w1)+(u1v1w1) */ \
/* */ \
/* alors que pour 'GAload_point_continu_lineaire(...)' : */ \
/* */ \
/* uUvVwW <-- a.(u0v0w0)+b.(u1v0w0)+c.(u0v1w0)+d.(u1v1w0) */ \
/* +e.(u0v0w1)+f.(u1v0w1)+g.(u0v1w1)+h.(u1v1w1) */ \
/* */ \
/* */ \
/* ou {a,b,c,d,e,f,g,h} sont dans [0,1]. */
#define Astore_point_continu_lineaire(fonction___au_point_uUvV,album,Xf,Yf,Zf,ecraser) \
Bblock \
GAstore_point_continu_lineaire(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,Aload_point_valide,Astore_point_valide \
,genere_p \
,GENP \
,ecraser \
); \
Eblock \
/* Procedure introduite le 20131231164141... */
#define AstoreF_point_continu_lineaire(fonction___au_point_uUvV,album,Xf,Yf,Zf,ecraser) \
Bblock \
GAstore_point_continu_lineaire(fonction___au_point_uUvV \
,album \
,Xf,Yf,Zf \
,AloadF_point_valide,AstoreF_point_valide \
,genere_Float \
,NEUT \
,ecraser \
); \
Eblock \
/* Procedure introduite le 20131231164141... */