/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D ' U N E S E R I E D ' I M A G E S */
/* D U T Y P E " D E V E L O P P E M E N T E N S E R I E " : */
/* */
/* */
/* Cette commande considere une image Argument */
/* comme la variable 'X' d'un polynome dont les */
/* coefficients sont constitues d'une liste d'images */
/* ('i' designant un indice de parcours de la liste */
/* 'Image') : */
/* */
/* 0 1 2 n */
/* R = Image(0).A + Image(1).A + Image(2).A + ... + Image(n).A */
/* */
/* ou reecrit a l'aide de la methode de Horner : */
/* */
/* R = (...(Image(n).A + Image(n-1)).A + ...).A + Image(0) */
/* */
/* */
/* Author of '$xci/accumule.04$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1997??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* Definition : */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
#include image_image_IMAGESF_EXT
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES \
VRAI \
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */ \
/* */ \
/* FAUX : le coefficient de la puissance 0 est la derniere image de la liste, */ \
/* VRAI : le coefficient de la puissance 0 est la premiere image de la liste. */ \
/* */
#include xci/accumule.03.I"
#include xci/accumule.01.I"
#define FAIRE_UN_PRODUIT_GENERALISE \
FAUX \
/* Dans le cas des images "standard" indique si l'addition et la multiplication sont faites */ \
/* via la notion de produit generalise ('VRAI') ou suivant l'arithmetique de base ('FAUX'). */
#define X_COEFFICIENT_M \
DIVI(FLOT(k___dimX),FLOT(COULEURS))
#define Y_COEFFICIENT_M \
DIVI(FLOT(k___dimY),FLOT(COULEURS))
/* Facteur multiplicatif permettant de "dilater" l'image 'TM' definissant la table de */
/* multiplication generalisee pour la composante "multiplication" du cumul. */
/* */
/* ATTENTION : le 20021002174320 ont ete introduits les 'FLOT(...)' dans les definitions */
/* ci-dessus, d'ou des risques d'incompatibilite avec des generations anterieures... */
#define X_TRANSLATION_M \
FZERO
#define Y_TRANSLATION_M \
FZERO
/* Translation de l'image 'T' definissant la table de multiplication generalisee pour la */
/* composante "multiplication" du cumul. */
/* */
/* ATTENTION : le 20021002174320 ont ete introduits les 'FLOT(...)' dans les definitions */
/* ci-dessus, d'ou des risques d'incompatibilite avec des generations anterieures... */
#define X_COEFFICIENT_A \
DIVI(FLOT(k___dimX),FLOT(COULEURS))
#define Y_COEFFICIENT_A \
DIVI(FLOT(k___dimY),FLOT(COULEURS))
/* Facteur multiplicatif permettant de "dilater" l'image 'TA' definissant la table de */
/* multiplication generalisee pour la composante "addition" du cumul. */
#define X_TRANSLATION_A \
FZERO
#define Y_TRANSLATION_A \
FZERO
/* Translation de l'image 'T' definissant la table de multiplication generalisee pour la */
/* composante "addition" du cumul. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/accumule.02.I"
#include xci/accumule.04.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C U M U L A T I O N D ' U N E S E R I E D ' I M A G E S */
/* D U T Y P E " D E V E L O P P E M E N T E N S E R I E " : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
/* Nom de l'image definissant la variable 'X' du polynome. */
DEFV(CHAR,INIC(POINTERc(nom_imageTM),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageTA),NOM_PIPE));
/* Nom des tables de Multiplication et d'Addition. */
DEFV(CHAR,INIC(POINTERc(nom_imageAP),NOM_PIPE));
/* Nom de la sequence definissant les coefficients du "Polynome". */
DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_imageAP><numero>. */
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom du Resultat de l'integration. */
DEFV(genere_Float,INIT(premiere_image,FLOT(PREMIERE_IMAGE)));
/* Numero de la premiere image, */
DEFV(genere_Float,INIT(derniere_image,FLOT(DERNIERE_IMAGE)));
/* Numero de la derniere image. */
DEFV(Int,INIT(translation_des_numeros_des_images,TRANSLATION_DES_NUMEROS_DES_IMAGES));
/* Les numeros d'images peuvent etre translates. Lorsque tel est le cas, le numero */
/* d'image utilise est le numero translate modulo {premiere,derniere}. */
DEFV(Logical,INIT(inverser_l_ordre_de_recuperation_des_images,INVERSER_L_ORDRE_DE_RECUPERATION_DES_IMAGES));
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */
/* */
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */
/* */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(genere_Float,INIT(numero_d_image,FLOT__UNDEF));
/* Numero de l'image courante. */
DEFV(genere_Float,INIT(pas_des_images,FLOT(PAS_DES_IMAGES)));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Float,INIT(facteur_A,FACTEUR_A));
DEFV(Float,INIT(facteur_B,FACTEUR_B));
/* Facteurs destines a transformer lineairement le numero d'image (A.n + B) */
DEFV(Logical,INIT(faire_un_produit_generalise,FAIRE_UN_PRODUIT_GENERALISE));
/* Dans le cas des images "standard" indique si l'addition et la multiplication sont faites */
/* via la notion de produit generalise ('VRAI') ou suivant l'arithmetique de base ('FAUX'). */
DEFV(coeffF_2D,coefficient_M);
/* Facteur multiplicatif permettant de "dilater" l'image 'TM' definissant la table de */
/* multiplication generalisee pour la composante "multiplication" du cumul. */
/* */
/* ATTENTION : le 20021002174320 'coefficient_M' est passe de 'coeffI_2D' a 'coeffF_2D' */
/* ci-dessus, d'ou des risques d'incompatibilite avec des generations anterieures... */
DEFV(deltaF_2D,trans_M);
/* Translation de l'image 'T' definissant la table de multiplication generalisee pour la */
/* composante "multiplication" du cumul. */
DEFV(table_de_multiplication_generalisee,table_de_multiplication_M);
/* Table de multiplication generalisee pour la composante "multiplication" du cumul. */
DEFV(coeffF_2D,coefficient_A);
/* Facteur multiplicatif permettant de "dilater" l'image 'TA' definissant la table de */
/* multiplication generalisee pour la composante "addition" du cumul. */
/* */
/* ATTENTION : le 20021002174320 'coefficient_A' est passe de 'coeffI_2D' a 'coeffF_2D' */
/* ci-dessus, d'ou des risques d'incompatibilite avec des generations anterieures... */
DEFV(deltaF_2D,trans_A);
/* Translation de l'image 'T' definissant la table de multiplication generalisee pour la */
/* composante "addition" du cumul. */
DEFV(table_de_multiplication_generalisee,table_de_multiplication_A);
/* Table de multiplication generalisee pour la composante "addition" du cumul. */
/*..............................................................................................................................*/
INITIALISATION_COEFFICIENT_2D(coefficient_M,X_COEFFICIENT_M,Y_COEFFICIENT_M);
/* Initialisation du facteur multiplicatif permettant de "dilater" l'image 'TM' definissant */
/* la table de multiplication generalisee pour la composante "multiplication" du cumul. */
INITIALISATION_ACCROISSEMENT_2D(trans_M,X_TRANSLATION_M,Y_TRANSLATION_M);
/* Initialisation de la translation de l'image 'T' definissant la table de multiplication */
/* generalisee pour la composante "multiplication" du cumul. */
INITIALISATION_COEFFICIENT_2D(coefficient_A,X_COEFFICIENT_A,Y_COEFFICIENT_A);
/* Initialisation du facteur multiplicatif permettant de "dilater" l'image 'TA' definissant */
/* la table de multiplication generalisee pour la composante "addition" du cumul. */
INITIALISATION_ACCROISSEMENT_2D(trans_A,X_TRANSLATION_A,Y_TRANSLATION_A);
/* Initialisation de la translation de l'image 'T' definissant la table de multiplication */
/* generalisee pour la composante "addition" du cumul. */
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("imageTM=""TM=",nom_imageTM);
GET_ARGUMENT_C("imageTA=""TA=",nom_imageTA);
GET_ARGUMENT_C("imageAP=""AP=",nom_imageAP);
GET_ARGUMENT_C("postfixe=",nom_postfixe);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_L("standard=",les_images_sont_standards);
GET_ARGUMENT_F("premiere=",premiere_image);
GET_ARGUMENT_F("derniere=",derniere_image);
GET_ARGUMENT_F("pas=",pas_des_images);
GET_ARGUMENT_I("modulo=",translation_des_numeros_des_images);
GET_ARGUMENT_L("inverser=",inverser_l_ordre_de_recuperation_des_images);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_F("fA=",facteur_A);
GET_ARGUMENT_F("fB=",facteur_B);
GET_ARGUMENT_L("produit_generalise=""generalise=",faire_un_produit_generalise);
GET_ARGUMENT_F("CxM=",ASD1(coefficient_M,cx));
GET_ARGUMENT_F("CyM=",ASD1(coefficient_M,cy));
GET_ARGUMENT_F("TxM=",ASD1(trans_M,dx));
GET_ARGUMENT_F("TyM=",ASD1(trans_M,dy));
GET_ARGUMENT_F("CxA=",ASD1(coefficient_A,cx));
GET_ARGUMENT_F("CyA=",ASD1(coefficient_A,cy));
GET_ARGUMENT_F("TxA=",ASD1(trans_A,dx));
GET_ARGUMENT_F("TyA=",ASD1(trans_A,dy));
)
);
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA,IFmageA,nom_imageA))))
Bblock
CALi(gInettoyage(les_images_sont_standards,ImageR,IFmageR));
/* Nettoyage de l'image Resultat afin d'initialisater l'algorithme de Horner... */
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas d'une image 'image' : */
Test(IL_NE_FAUT_PAS(faire_un_produit_generalise))
Bblock
CALi(IFinitialisation(IFmageR,FZERO));
/* Initialisation de l'image Resultat car le calcul aura lieu en flottant... */
CALS(Istd_float(IFmageA,______________NOIR_NORMALISE,______________BLANC_NORMALISE,ImageA));
/* Conversion flottante de l'image Argument. */
Eblock
ATes
Bblock
CALi(Inoir(ImageA3));
CALi(Inoir(ImageA4));
/* A priori... */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA3,nom_imageTM))))
Bblock
/* Chargement de la table de Multiplication. */
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA4,nom_imageTA))))
Bblock
/* Chargement de la table d'Addition. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
INITIALISATION_QUELCONQUE_TABLE_DE_MULTIPLICATION
(table_de_multiplication_M
,load_point_valide(ImageA3
,COXA(INTE(AXPB(ASD1(coefficient_M,cx)
,NIVR(SE12(niveau1,niveau2))
,_lDENORMALISE_OX(ASD1(trans_M,dx))
)
)
)
,COYA(INTE(AXPB(ASD1(coefficient_M,cy)
,NIVR(SE22(niveau1,niveau2))
,_lDENORMALISE_OY(ASD1(trans_M,dy))
)
)
)
)
);
/* Initialisation de la table de multiplication generalisee pour la composante */
/* "multiplication" du cumul. */
INITIALISATION_QUELCONQUE_TABLE_DE_MULTIPLICATION
(table_de_multiplication_A
,load_point_valide(ImageA4
,COXA(INTE(AXPB(ASD1(coefficient_A,cx)
,NIVR(SE12(niveau1,niveau2))
,_lDENORMALISE_OX(ASD1(trans_A,dx))
)
)
)
,COYA(INTE(AXPB(ASD1(coefficient_A,cy)
,NIVR(SE22(niveau1,niveau2))
,_lDENORMALISE_OY(ASD1(trans_A,dy))
)
)
)
)
);
/* Initialisation de la table de multiplication generalisee pour la composante */
/* "addition" du cumul. */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
Test(IL_FAUT(faire_un_produit_generalise))
Bblock
PRINT_ATTENTION("il est impossible d'utiliser les produits generalises avec les images non standards");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
Test(IFNE(numero_d_image,fINTE(numero_d_image)))
Bblock
PRINT_ATTENTION("le numero de l'image courante n'est pas entier et va donc etre tronque");
Eblock
ATes
Bblock
Eblock
ETes
EGAL(nom_image
,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
,chain_Aconcaten2_sauf_nom_pipe(nom_imageAP
,chain_numero_modulo(INTE(NUMERO_D_IMAGE),nombre_de_chiffres)
)
,chain_Aconcaten3_sauf_nom_pipe(nom_imageAP
,chain_numero_modulo(INTE(NUMERO_D_IMAGE),nombre_de_chiffres)
,nom_postfixe
)
)
);
/* Le 20221212114501, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'... */
Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA1,IFmageA1,nom_image))))
Bblock
/* 'ImageA1' donne le coefficient 'image(i)'. */
Test(EST_VRAI(les_images_sont_standards))
Bblock
/* Cas d'une image 'image' : */
Test(IL_FAUT(faire_un_produit_generalise))
Bblock
CALS(Iproduit_generalise(ImageR,ImageR,ImageA,table_de_multiplication_M));
CALS(Iproduit_generalise(ImageR,ImageR,ImageA1,table_de_multiplication_A));
/* Calcul de : */
/* */
/* R = (R.A)*image(i-1) */
/* */
/* (via les tables de multiplication 'M'='.' et 'A'='*') avec : */
/* */
/* R = NOIR */
/* */
/* initialement... */
Eblock
ATes
Bblock
CALS(Istd_float(IFmageA1,______________NOIR_NORMALISE,______________BLANC_NORMALISE,ImageA1));
/* Conversion flottante de l'image donnant le coefficient courant... */
CALS(IFmultiplication_et_cumul_avec_renormalisation(IFmageR,IFmageR,IFmageA,IFmageA1));
/* Calcul de : */
/* */
/* R = (R.A) + image(i-1) */
/* */
/* (via la multiplication standard '.') avec : */
/* */
/* R = NOIR */
/* */
/* initialement... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas d'une image 'imageF' : */
CALS(IFmultiplication_et_cumul_avec_renormalisation(IFmageR,IFmageR,IFmageA,IFmageA1));
/* Calcul de : */
/* */
/* R = (R.A) + image(i-1) */
/* */
/* (via la multiplication standard '.') avec : */
/* */
/* R = NOIR */
/* */
/* initialement... */
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
CALZ_FreCC(nom_image);
Eblock
EDoI
Test(IFET(EST_VRAI(les_images_sont_standards),IL_NE_FAUT_PAS(faire_un_produit_generalise)))
Bblock
CALS(Ifloat_std_avec_renormalisation(ImageR,IFmageR));
/* Conversion flottante de l'image Argument. */
Eblock
ATes
Bblock
Eblock
ETes
CALi(gIupdate_image(les_images_sont_standards,nom_imageR,ImageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
RETU_Commande;
Eblock
ECommande