_______________________________________________________________________________________________________________________________________
/* ATTENTION : a cause des references en avant 'Iload_fichier', 'Iload_fichier_and_delete' */
/* et 'Istore_fichier', le fichier $xiii/files$FON' doit etre constitue d'un seul bloc... */
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E B A S E D E G E S T I O N D E S F I C H I E R S " I M A G E S " : */
/* */
/* */
/* Definition : */
/* */
/* Ce fichier contient toutes les fonctions */
/* de base de gestion des fichiers de type */
/* images raster, quelle que soit la definition. */
/* */
/* */
/* Author of '$xiii/files$FON' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19870000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U D I R E C T O R Y " images " E T A U D I R E C T O R Y " palettes " : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(files_____faciliter_l_acces_au_directory_images,VRAI)));
/* Afin de pouvoir inhiber le dispositif introduit le 20020512101004 (ceci ayant ete */
/* introduit le 20020514152338). */
#define ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE \
FAUX
#define NOM_FICHIER_DESIGNE_UNE_PALETTE \
NOTL(ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE)
DEFV(Local,DEFV(Logical,INIT(NOM_FICHIER_designe_une_palette,ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE)));
/* Afin d'etendre la "puissance" de la definition de 'NOM_FICHIER', ce dispositif ayant ete */
/* introduit le 20020512101004. Ce dispositif peut etre inhibe grace a l'indicateur */
/* precedent 'files_____faciliter_l_acces_au_directory_images'... */
#define ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE \
Bblock \
EGAL(NOM_FICHIER_designe_une_palette,ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE); \
Eblock
#define ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE \
Bblock \
EGAL(NOM_FICHIER_designe_une_palette,NOM_FICHIER_DESIGNE_UNE_PALETTE); \
Eblock
/* Procedures destinees a positionner 'NOM_FICHIER_designe_une_palette'... */
#define NOM_FICHIER \
COND(IFEQ(PREMIER_CARACTERE_ITb0(nom_fichier),RACINE_DU_SYSTEME) \
,nom_fichier \
,EGAs(chain_Aconcaten2(COND(IL_FAUT(files_____faciliter_l_acces_au_directory_images) \
,COND(EST_FAUX(NOM_FICHIER_designe_une_palette),directory_images,directory_palettes) \
,directory_images \
) \
,nom_fichier \
) \
) \
) \
/* Generation du nom absolu d'un fichier de type "image", lorsqu'il ne l'est pas deja ; ce */ \
/* test est fait simplement en regardant le premier caractere du nom... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E X E C U T I O N E V E N T U E L L E D E P L U S I E U R S F O N C T I O N S : */
/* */
/*************************************************************************************************************************************/
#define EXECUTE_PLUSIEURS_FONCTIONS(Fonction1,Fonction2) \
Bblock \
Test(IL_Y_A_ERREUR(CODE_ERROR(Fonction1))) \
/* Tentative d'execution de la premiere fonction 'Fonction1'. */ \
Bblock \
CODE_ERROR(Fonction2); \
/* En cas d'erreur dans 'Fonction1', on tente la deuxieme fonction 'Fonction2'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Execution de 'Fonction1' puis eventuellement de 'Fonction2' si 'Fonction1' a echoue... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D E L ' E S P A C E - D I S Q U E L I B R E : */
/* */
/*************************************************************************************************************************************/
#ifndef BUG_SYSTEME_COMMANDE_SYSTEM_1 /* Common,DEFV(Fonction,) : commande 'SYSTEM(...)' utilise 'sh' et non pas 'csh'. */
BFonctionI
# define NOM_DE_LA_COMMANDE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES \
"quid" \
/* Nom de la commande 'C-Shell' donnant le nombre d'images libres... */
# define NOM_DE_LA_VARIABLE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES \
"iFREE" \
/* Nom de la variable 'C-Shell' donnant le nombre d'images libres... */
# define TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE \
DEUX \
/* Lorsqu'il n'y a pas suffisamment d'espace-disque de libre, on attend un certain temps */ \
/* avant de renouveler le test... */
DEFV(Common,DEFV(FonctionI,Itest_espace_disque_libre(nombre_d_images_libres)))
DEFV(Argument,DEFV(Positive,nombre_d_images_libres));
/* Nombre d'images libres qui sont necessaires... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(Logical,INIT(attendre_de_la_place,VRAI));
/* Indicateur qui lorsqu'il est 'VRAI' signifie qu'il faut boucler jusqu'a ce que le */
/* nombre d'images demande soit libre... */
DEFV(CHAR,INIT(POINTERc(commande_quid),COMMANDE_UNDEF));
/* Afin d'envoyer une commande donnant l'espace-disque libre... */
DEFV(Int,INIT(compte_rendu,UNDEF));
/* Compte_rendu de 'NOM_DE_LA_COMMANDE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES'... */
/*..............................................................................................................................*/
EGAp(commande_quid
,chain_Aconcaten3(NOM_DE_LA_COMMANDE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES
,C_SH__REDIRECTION_FICHIER
,PAS_D_ENTREES_SORTIES
)
);
/* Generation de la commande donnant l'espace-disque libre... */
/* */
/* Passage de 'C_REDIRECTION_FICHIER' a 'C_SH__REDIRECTION_FICHIER' le 20111117081100... */
Tant(IL_FAUT(attendre_de_la_place))
Bblock
EGAL(compte_rendu,SYSTEM(commande_quid));
/* Execution de la commande donnant l'espace disque encore libre... */
Test(PAS_D_ERREUR(compte_rendu))
Bblock
Test(IFGE(Gval(NOM_DE_LA_VARIABLE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES)
,nombre_d_images_libres
)
)
Bblock
EGAL(attendre_de_la_place,FAUX);
/* Des qu'il y a assez de place, on arrete d'attendre... */
Eblock
ATes
Bblock
DODO(TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE);
/* S'il n'y a pas assez de place, on attend un peu avant de renouveler le test... */
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la commande 'quid' n'a pas ete executee");
Eblock
ETes
Eblock
ETan
CALZ_FreCC(commande_quid);
RETU_ERROR;
Eblock
# undef TEMPORISATION_D_ATTENTE_D_ESPACE_DISQUE
# undef NOM_DE_LA_VARIABLE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES
# undef NOM_DE_LA_COMMANDE_DU_C_SHELL_DONNANT_LE_NOMBRE_D_IMAGES_LIBRES
EFonctionI
#Aifndef BUG_SYSTEME_COMMANDE_SYSTEM_1 /* Common,DEFV(Fonction,) : commande 'SYSTEM(...)' utilise 'sh' et non pas 'csh'. */
#Eifndef BUG_SYSTEME_COMMANDE_SYSTEM_1 /* Common,DEFV(Fonction,) : commande 'SYSTEM(...)' utilise 'sh' et non pas 'csh'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D E L ' E X I S T E N C E D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Itest_fichier(nom_fichier)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier a tester. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(I3ET(IFNE_chaine(nom_fichier,C_VIDE)
,IFNE_chaine(nom_fichier,NOM_PIPE)
,IFNE_chaine(nom_fichier,NOM_PIPE_Local)
)
)
Bblock
CODE_ERROR(Ftest_fichier(NOM_FICHIER,EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS));
/* Test de l'existence du fichier uniquement dans le directory "images"... */
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A L A T A I L L E D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define TAILLE_RENVOYEE_POUR_UN_PIPE \
PRED(ZERO) \
/* Taille renvoyee dans le cas d'un "pipe". ATTENTION, a cause de cela, une taille de */ \
/* fichier ne peut etre range dans un 'Positive', il lui faut uniquement dans un 'Int'... */
BFonctionI
DEFV(Common,DEFV(FonctionI,Isize_fichier(nom_fichier,ARGUMENT_POINTEUR(size_image))))
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier dont on veut la taille. */
DEFV(Argument,DEFV(Int,POINTEUR(size_image)));
/* Et pointeur ('ADRESSE') sur la taille en octets. */
/* */
/* ATTENTION, a cause de 'TAILLE_RENVOYEE_POUR_UN_PIPE', la taille ne peut etre un */
/* 'Positive' et donc doit etre obligatoirement un 'Int'... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(I3ET(IFNE_chaine(nom_fichier,C_VIDE)
,IFNE_chaine(nom_fichier,NOM_PIPE)
,IFNE_chaine(nom_fichier,NOM_PIPE_Local)
)
)
Bblock
EXECUTE_PLUSIEURS_FONCTIONS(Fsize_fichier(NOM_FICHIER,size_image,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS)
,Fsize_fichier(nom_fichier,size_image,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS)
);
/* Tentative de recuperation de la taille d'un fichier d'abord dans le directory "images", */
/* lorsque le nom n'est pas vide ; en cas d'erreur dans le directory "images", */
/* on consulte le directory courant. */
Eblock
ATes
Bblock
EGAL(INDIRECT(size_image),TAILLE_RENVOYEE_POUR_UN_PIPE);
/* Dans le cas d'un "pipe", on renvoie une valeur particuliere... */
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A L A T A I L L E D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Isize_image(nom_image)))
/* Fonction introduite le 20060308101621... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom du fichier dont on veut la taille. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(taille_de_l_image,TAILLE_D_UNE_IMAGE_UNDEF));
/* Taille de l'image en octets. La valeur par defaut est passee le 20060908185742 de 'UNDEF' */
/* a 'TAILLE_D_UNE_IMAGE_UNDEF' pour 'v $xiii/files$DEF LES_IMAGES_SONT_ELLES_STANDARDS' */
/* afin de pouvoir ainsi distinguer les images inexistantes, en particulier lors de la */
/* detection automatique des images standards... */
/* */
/* ATTENTION : a cause de la definition de 'v $xiii/files$DEF TAILLE_D_UNE_IMAGE_UNDEF' */
/* (qui contient un 'NEGA(...)'), la variable 'taille_de_l_image' doit imperativement etre */
/* un 'Int' et non pas un 'Positive'... */
/*..............................................................................................................................*/
CALS(Isize_fichier(nom_image,ADRESSE(taille_de_l_image)));
RETU(taille_de_l_image);
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E S T R U C T I O N D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Idelete_fichier(nom_fichier)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(I3ET(IFNE_chaine(nom_fichier,C_VIDE)
,IFNE_chaine(nom_fichier,NOM_PIPE)
,IFNE_chaine(nom_fichier,NOM_PIPE_Local)
)
)
Bblock
EXECUTE_PLUSIEURS_FONCTIONS(Fdelete_fichier(NOM_FICHIER,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS)
,Fdelete_fichier(nom_fichier,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS)
);
/* Tentative de destruction d'un fichier d'abord dans le directory "images", */
/* lorsque le nom n'est pas vide ; en cas d'erreur dans le directory "images", */
/* on consulte le directory courant. */
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A N I P U L A T I O N D ' U N O B J E T E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
#define MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_l_objet,type_de_la_composante,espace_de_couleurs,manipulateur,manipuler) \
Bblock \
Test(IL_FAUT(manipuler)) \
Bblock \
DEFV(Int,INIT(code_d_erreur_anterieur,CODE_ERREUR)); \
/* Sauvegarde du code d'erreur avant la sequence 'manipulateur'. */ \
DEFV(CHAR,INIT(POINTERc(nom_composante_objet) \
,chain_Aconcaten2_sauf_nom_pipe(nom_de_l_objet,c`type_de_la_composante(espace_de_couleurs)) \
) \
); \
/* Generation du nom de la composante. */ \
BLOC(manipulateur); \
/* Manipulation arbitraire de la composante courante d'un objet en couleurs... */ \
CALZ_FreCC(nom_composante_objet); \
/* Puis enfin, liberation du nom de la composante... */ \
CODE_ERROR(COND(IL_Y_A_ERREUR(CODE_ERREUR),CODE_ERREUR,code_d_erreur_anterieur)); \
/* S'il y a eu erreur dans la sequence 'manipulateur', c'est ce dernier code d'erreur qui */ \
/* est renvoye, sinon, c'est le code d'erreur anterieur (c'est-a-dire tel qu'il etait avant */ \
/* la sequence 'manipulateur') qui l'est... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Manipulation arbitraire d'une composante d'un objet en couleurs... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A N I P U L A T I O N D ' U N E I M A G E E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
#define nom_composante_image \
nom_composante_objet \
/* Pour ameliorer la lisibilite... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* N O T I O N D E " C O M M A N D E - F I C H I E R " : */
/* */
/* */
/* Definition : */
/* */
/* Lorsqu'un nom de fichier commencera par */
/* le caractere ":", on considerera que la */
/* chaine de caractere qui suit est en fait */
/* le nom d'une commande a executer ; celle-ci */
/* creera un fichier temporaire qui sera donc */
/* ensuite utilise comme s'il avait pre-existe... */
/* */
/* En general, il conviendra d'encadrer la */
/* chaine argument entre des double-quotes '"', */
/* afin de permettre a la commande d'avoir elle- */
/* meme des arguments 'Arg1',...,'ArgN'. Ainsi, */
/* 'csh' etant en general obligatoire afin de */
/* beneficier des variables-shell, on ecrira : */
/* */
/* A=":$CSH commande Arg1 Arg2...ArgN" */
/* */
/* 'A' designant l'introducteur d'un argument */
/* d'une commande (par exemple de $xci). */
/* */
/*************************************************************************************************************************************/
#define INTRODUCTION_D_UNE_COMMANDE_FICHIER \
K_DEUX_POINTS \
/* Caractere introduisant une "commande-fichier". */
#define NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER \
generation_d_un_nom_absolu_dans_xT_temporaire(C_VIDE) \
/* Nom du fichier temporaire cree lors de l'execution d'une "commande-fichier" ; le */ \
/* nom '.remote' est choisi parce qu'en general, c'est une image recuperee a distance... */ \
/* */ \
/* Jusqu'au 20090418125422, il y avait ici : */ \
/* */ \
/* #define NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER \ */ \
/* directory_images_manoeuvre/.remote" */ \
/* */ \
/* meme si cela ne sert plus a rien depuis des lustres, cela fut "modernise" a cette date... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' E Q U I V A L E N C E S P O U R L E S */
/* E N T R E E S - S O R T I E S D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
Dunion_13(EQUIVALENCE_DES_FICHIERS_IMAGES
,DEFV(CHAR,POINTEUR(fichier_non_type));
,DEFV(genere_p,POINTEUR(fichier_type_image));
,DEFV(genere_CHAR,POINTEUR(fichier_type_imageC));
,DEFV(genere_vrai_Int_de_base,POINTEUR(fichier_type_imageIB));
,DEFV(genere_Int,POINTEUR(fichier_type_imageI));
,DEFV(genere_vrai_Positive_de_base,POINTEUR(fichier_type_imageUB));
,DEFV(genere_LPositive,POINTEUR(fichier_type_imageU));
,DEFV(genere_Float,POINTEUR(fichier_type_imageF));
,DEFV(genere_Double,POINTEUR(fichier_type_imageD));
,DEFV(genere_complexe,POINTEUR(fichier_type_imageJ));
,DEFV(genere_hyper_complexe,POINTEUR(fichier_type_imageHJ));
,DEFV(genere_hyper_hyper_complexe,POINTEUR(fichier_type_imageHHJ));
,DEFV(genere_p,POINTEUR(fichier_type_liste_de_substitution));
,NOM_VIDE
);
/* Le type 'genere_hyper_hyper_complexe' a ete introduit le 20150227110432... */
Typedef(equivalence_des_fichiers_images,UNIO(EQUIVALENCE_DES_FICHIERS_IMAGES))
/* Definition d'une equivalence entre tous les fichiers de type 'liste_de_substitution' et */
/* 'image' destinee a permettre leur acces via les seules fonctions 'Iload_fichier(...)' et */
/* 'Istore_fichier(...)' quel qu'en soit le type reel... Ceci a ete introduit a cause des */
/* SYSTEMEs 'SYSTEME_SGIND?GA_IRIX_CC' ce qui simultanement a permis de traiter le cas de */
/* 'SYSTEME_ES9000_AIX_CC' qui avait ete resolu incompletement en son temps en deplacant */
/* les sequences relatives aux fonctions 'Iload_fichier(...)' et 'Istore_fichier(...)', ce */
/* etait, on en conviendra aisement, pas tres elegant... */
#define EQUIVALENCE_FICHIER(fichier,type_fichier) \
DEFV(equivalence_des_fichiers_images,fichier_equivalent); \
EGAL(ASD1(fichier_equivalent,type_fichier),fichier); \
/* Definition de l'equivalence d'un fichier de type donne avec un fichier "general"... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R D A N S L E P I P E S I L E N O M E S T V I D E */
/* S I N O N */
/* D A N S L E D I R E C T O R Y " i m a g e s " */
/* P U I S */
/* D A N S L E D I R E C T O R Y C O U R A N T */
/* S I E R R E U R : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
,EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS
)
)
);
/* Cet indicateur indique si les messages d'erreur de 'Fload_fichier_non_formatte(...)' */
/* doivent apparaitre ou pas. En temps normal, ils apparaitront, mais de temps en temps, */
/* lorsque par exemple une image sert de synchronisateur entre deux programmes, on pourra */
/* les inhiber par 'NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS'... */
#define ILOAD_FICHIER(nom_fichier,fichier,size_fichier,unite_fichier,type_fichier) \
Bblock \
EQUIVALENCE_FICHIER(fichier,type_fichier); \
CODE_ERROR(Iload_fichier(nom_fichier \
,ASD1(fichier_equivalent,fichier_non_type) \
,INTE(size_fichier) \
,INTE(unite_fichier) \
) \
); \
Eblock \
/* Acces a un fichier de type donne. On notera l'introduction de : */ \
/* */ \
/* INTE(size_fichier) */ \
/* */ \
/* rendu obligatoire sur 'SYSTEME_SGPCM801_IRIX_CC' apres l'introduction de la version */ \
/* '600020000' de '$nC_RELEASE' qui, apparemment "caste" les 'size_fichier' a cause de */ \
/* l'utilisation de 'sizeof(...)' dans 'SIZE_GENERAL', ce "cast" etant apparemment */ \
/* incompatible avec le type attendu pour 'size_fichier' (soit 'Int'). */
#define ILOAD_FICHIER_AVEC_CONVERSION(No,file,size_file,unite_file,type_file,tenter,type,f_conv,Finit,initErr,val_error,errNo_absent) \
/* L'argument logique 'initErr' a ete introduit le 20101118103438 afin de pouvoir bloquer, */ \
/* si besoin est, l'initialisation du fichier par 'Finit(...)' en cas d'erreur et cela pour */ \
/* principalement 'v $xci/sequence$K Iload_image_____initialiser_en_cas_d_erreur_fichier' */ \
/* et donc permettre un reaffichage correct de l'image precedente dans le cas ou l'image */ \
/* courante n'existe pas (ou pas encore...). */ \
Bblock \
Test(IFET(EST_FAUX(errNo_absent) \
,I3OU(IFEQ_chaine(No,C_VIDE) \
,IFEQ_chaine(No,NOM_PIPE) \
,IFEQ_chaine(No,NOM_PIPE_Local) \
) \
) \
) \
/* Test introduit le 20080212093518... */ \
Bblock \
DEFV(type,INIT(valeur_des_elements_du_fichier_lorsque_son_nom_est_absent,val_error)); \
/* Variable introduite le 20080212145410 uniquement afin de faire la difference entre */ \
/* les differents usages qui sont faits de 'val_error'... */ \
\
CALS(Finit(file,valeur_des_elements_du_fichier_lorsque_son_nom_est_absent)); \
/* Lorsque le nom est vide, cela ne constitue plus necessairement une erreur a compter du */ \
/* 20080212093518, a condition evidemment que cela soit autorise (via 'errNo_absent'...). */ \
Eblock \
ATes \
Bblock \
DEFV(Logical,INIT(le_nom_du_fichier_a_ete_converti_en_une_valeur_numerique,FAUX)); \
/* Indicateur precisant si le nom du fichier a ete converti en une valeur numerique ou pas. */ \
\
gLOAD_FICHIER_AVEC_CONVERSION(No \
,tenter \
,type \
,f_conv \
,BLOC(Bblock \
CALS(Finit(file,valeur_du_nom)); \
/* Initialisation du fichier sans lecture... */ \
Eblock \
) \
,le_nom_du_fichier_a_ete_converti_en_une_valeur_numerique \
); \
\
Test(EST_FAUX(le_nom_du_fichier_a_ete_converti_en_une_valeur_numerique)) \
/* Cas ou il faut lire le fichier de nom 'No' : */ \
Bblock \
ILOAD_FICHIER(No,file,size_file,unite_file,type_file); \
\
Test(IL_Y_A_ERREUR(CODE_ERREUR)) \
Bblock \
DEFV(type,INIT(valeur_des_elements_du_fichier_lorsque_son_acces_est_impossible,val_error)); \
/* Variable introduite le 20080212145410 uniquement afin de faire la difference entre */ \
/* les differents usages qui sont faits de 'val_error'... */ \
\
Test(IL_FAUT(initErr)) \
/* Test introduit le 20101118103438... */ \
Bblock \
CALS(Finit(file,valeur_des_elements_du_fichier_lorsque_son_acces_est_impossible)); \
/* Lorsqu'il y a erreur, on renvoie l'image initialisee avec une valeur par defaut (ce */ \
/* dispositif a ete introduit le 20021004150125 ; avant cette date, seule la fonction */ \
/* 'Iacces_image(...)' procedait explicitement a une initialisation a 'NOIR' en cas de */ \
/* probleme...). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
/* Cas ou le nom 'No' du fichier argument etait une bonne valeur numerique... */ \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
/* Acces a un fichier de type donne avec generation si le nom est une valeur numerique. */
BFonctionI
DEFV(Common,DEFV(Logical,SINT(Iload_fichier_____tester_le_debordement_du_pipe,TESTER_LE_DEBORDEMENT_DU_PIPE_DANS_Iload_fichier)));
/* Cet indicateur introduit le 19980520185424 permet de ne pas tester s'il reste des octets */
/* residuels apres une lecture dans 'Iload_fichier(...)'. Cela a ete introduit, par exemple, */
/* a cause de l'alias 'videoF' ('v $Fdivers videoF') qui echange entre '$xci/vraies_C$X' et */
/* '$xci/Sdisplay_RVB$X' des triplets d'image {$ROUGE,$VERTE,$BLEUE}. Ainsi, apres la */
/* premiere image, par exemple, il en reste deux dans le pipe. On notera au passage qu'il */
/* serait tres utile de pouvoir connaitre le dernier 'Iload_fichier(...)' d'un programme */
/* car c'est en fait sur lui que ce test de debordement serait utile ; malheureusement, il */
/* est trivial de connaitre le premier 'Iload_fichier(...)', par contre, en ce qui concerne */
/* le dernier... */
DEFV(Common,DEFV(FonctionI,Iload_fichier(nom_fichier,fichier,size_fichier,unite_fichier)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier a lire (lorsque le nom est vide ("") on utilise un pipe), */
DEFV(Argument,DEFV(CHAR,DTb0(fichier)));
/* Ou le mettre en memoire, */
DEFV(Argument,DEFV(Int,size_fichier));
/* Et taille en octets. */
DEFV(Argument,DEFV(Int,unite_fichier));
/* Nombre d'octets dans l'unite du fichier. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(Int,INIT(nombre_total_d_octets_recuperes,FICHIER_VIDE));
/* Lors de l'entree standard, on recupere le nombre total d'octets recuperes */
/* et ce afin de detecter la fin du flot. L'initialisation est faite avec 'FICHIER_VIDE' */
/* au cas ou le test 'Fflags(...)' serait negatif... */
/*..............................................................................................................................*/
INITIALISATION_D_UNE_IMAGE_ET_VALIDATION_DES_IMAGES_STATIQUES(fichier
,BLOC(VIDE;)
,BLOC(VIDE;)
);
/* Introduit le 20090317091517 car, en effet, cette validation avant cette date n'etait */
/* faite que dans 'v $xiii/mono_image$FON INITIALISATION_D_UNE_IMAGE_ET_VALIDATION_DES_...' */
/* ce qui etait insuffisant... */
Test(I3OU(IFEQ_chaine(nom_fichier,C_VIDE)
,IFEQ_chaine(nom_fichier,NOM_PIPE)
,IFEQ_chaine(nom_fichier,NOM_PIPE_Local)
)
)
Bblock
Test(EST_VRAI(STANDARD_IN_EST_UN_PIPE))
Bblock
/* Cas ou une entree "pipe" a ete demandee, alors qu'il semble y avoir un "pipe" en entree */
/* (voir le fichier 'v $xtc/files.11$c' en ce qui concerne ce test...). */
/* */
/* ATTENTION, il est impossible d'utiliser ici le test suivant : */
/* */
/* IZNE(ETLO(Fflags(STANDARD_IN),OPEN_READ)) */
/* */
/* comme cela a etait fait le 20040914090620 dans 'Istore_fichier(...)' car, en effet, */
/* la valeur 'OPEN_READ' est nulle et donc le 'IZNE(...)' serait toujours faux... */
/* */
/* L'appel a 'STANDARD_IN_EST_UN_PIPE' a ete introduit le 20051117102806... */
DEFV(Int,INIT(nombre_d_octets_restant_a_lire,size_fichier));
/* Au cas ou la lecture se ferait en plusieurs 'Read'... */
DEFV(Int,INIT(nombre_d_octets_recuperes,UNDEF));
/* Lors de l'entree standard, on recupere le nombre d'octets recuperes par 'Read'. */
DEFV(CHAR,INIT(POINTERc(buffer_courant),fichier));
/* On utilise un pointeur courant dans le buffer, au cas ou la lecture par 'Read' */
/* se ferait en plusieurs fois... */
DEFV(CHAR,INIT(reste_t_il_des_octets,K_UNDEF));
/* Pour voir si par hasard il n'y aurait pas d'autres octets derriere ceux que l'on vient */
/* de recuperer dans fichier'... */
Tant(IFET(IFLT(nombre_total_d_octets_recuperes,size_fichier)
,IFNE(EGAL(nombre_d_octets_recuperes,Read(STANDARD_IN,buffer_courant,nombre_d_octets_restant_a_lire))
,FICHIER_VIDE
)
)
)
Bblock
/* Acces a l'entree standard lorsque le nom demande est vide ("") ; on pourra */
/* "piper" plusieurs programmes entre-eux ; on notera que si le fichier est */
/* bien de type "image", 'CODE_ERREUR' est deja 'OK' par initialisation... */
DECR(nombre_d_octets_restant_a_lire,nombre_d_octets_recuperes);
/* Au cas ou la lecture se ferait en plusieurs 'Read'... */
INCR(nombre_total_d_octets_recuperes,nombre_d_octets_recuperes);
/* Cumul des octets recuperes, */
INCR(buffer_courant,nombre_d_octets_recuperes);
/* Et de l'adresse du buffer courant... */
Eblock
ETan
Test(IL_FAUT(Iload_fichier_____tester_le_debordement_du_pipe))
/* On notera qu'il serait tres utile de pouvoir connaitre le dernier 'Iload_fichier(...)' */
/* d'un programme car c'est en fait sur lui que ce test de debordement serait utile ; */
/* malheureusement, il est trivial de connaitre le premier 'Iload_fichier(...)', par contre, */
/* en ce qui concerne le dernier... */
Bblock
Test(IFNE(Read(STANDARD_IN,ADRESSE(reste_t_il_des_octets),SIZE_GENERAL(reste_t_il_des_octets)),FICHIER_VIDE))
Bblock
PRINT_ERREUR("il semble qu'il reste des octets dans le 'pipe'");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou une entree "pipe" a ete demandee, alors qu'il ne semble pas y avoir de "pipe" en */
/* entree, mais uniquement la "vraie" entree standard... */
begin_nouveau_block
Bblock
DEFV(CHAR,INIC(POINTERc(format_EGAq____Iload_fichier)
,chain_Aconcaten2("un (le ","?) 'pipe' d'entree semble absent")
)
);
PRINT_ERREUR(format_EGAq____Iload_fichier);
/* La presence de 'chain_Aconcaten2(...)' est rendue necessaire par la presence d'un espace */
/* devant le caractere "?", espace qui disparait alors dans 'v $xcc/cpp$D/compacte.1$sed'... */
CALZ_FreCC(format_EGAq____Iload_fichier);
Eblock
end_nouveau_block
CODE_ERROR(ERREUR31);
/* Introduit le 20110224094715... */
Eblock
ETes
Test(IFNE(nombre_total_d_octets_recuperes,size_fichier))
Bblock
Test(IFEQ(nombre_total_d_octets_recuperes,FICHIER_VIDE))
Bblock
CODE_ERROR(ERREUR07);
/* Cas des fins de flot... */
Eblock
ATes
Bblock
CODE_ERROR(ERREUR13);
/* Cas des vraies erreurs... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Test(IFEQ(PREMIER_CARACTERE_ITb0(nom_fichier),INTRODUCTION_D_UNE_COMMANDE_FICHIER))
Bblock
CALS(Idelete_fichier(NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER));
/* Petit nettoyage preliminaire... */
Test(PAS_D_ERREUR(SYSTEM(SUCC(nom_fichier))))
Bblock
/* On execute la commande qui suit le caractere d'introduction ; on fait l'hypothese */
/* qu'elle va generer une image temporaire la ou on va la recuperer ensuite... */
Test(IL_Y_A_ERREUR(Iload_fichier(NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER,fichier,size_fichier,unite_fichier)))
/* Et on essaye de la recuperer... */
Bblock
PRINT_ERREUR("lors d'une 'commande-fichier', le fichier-image de manoeuvre n'existe pas");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("lors d'une 'commande-fichier' il y a eu un probleme");
Eblock
ETes
CALS(Idelete_fichier(NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER));
/* Petit nettoyage a la fin dans tous les cas... */
Eblock
ATes
Bblock
EXECUTE_PLUSIEURS_FONCTIONS(Fload_fichier_non_formatte(NOM_FICHIER
,fichier
,size_fichier
,unite_fichier
,COND(IL_FAUT(attendre_un_fichier_inexistant_ou_non_conforme)
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS
)
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
)
,Fload_fichier_non_formatte(nom_fichier
,fichier
,size_fichier
,unite_fichier
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
)
);
/* Tentative d'ouverture d'un fichier d'abord dans le directory "images", */
/* lorsque le nom n'est pas vide ; en cas d'erreur dans le directory "images", */
/* on consulte le directory courant. On notera la modification apportee le 20020626102936 */
/* relative a 'files_____editer_les_messages_d_erreur_de_lecture_des_fichiers' et qui est */
/* decrite dans 'v $xig/fonct$vv$FON 20020626101948'. */
Eblock
ETes
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R D A N S L E P I P E S I L E N O M E S T V I D E */
/* S I N O N */
/* D A N S L E D I R E C T O R Y " i m a g e s " */
/* P U I S */
/* D A N S L E D I R E C T O R Y C O U R A N T */
/* S I E R R E U R P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
#define ILOAD_FICHIER_AND_DELETE(nom_fichier,fichier,size_fichier,unite_fichier,type_fichier) \
Bblock \
EQUIVALENCE_FICHIER(fichier,type_fichier); \
CODE_ERROR(Iload_fichier_and_delete(nom_fichier \
,ASD1(fichier_equivalent,fichier_non_type) \
,INTE(size_fichier) \
,INTE(unite_fichier) \
) \
); \
Eblock \
/* Acces a un fichier de type donne et destruction. On notera l'introduction de : */ \
/* */ \
/* INTE(size_fichier) */ \
/* */ \
/* rendu obligatoire sur 'SYSTEME_SGPCM801_IRIX_CC' apres l'introduction de la version */ \
/* '600020000' de '$nC_RELEASE' qui, apparemment "caste" les 'size_fichier' a cause de */ \
/* l'utilisation de 'sizeof(...)' dans 'SIZE_GENERAL', ce "cast" etant apparemment */ \
/* incompatible avec le type attendu pour 'size_fichier' (soit 'Int'). */
BFonctionI
DEFV(Common,DEFV(FonctionI,Iload_fichier_and_delete(nom_fichier,fichier,size_fichier,unite_fichier)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier a lire (lorsque le nom est vide ("") on utilise un pipe), */
DEFV(Argument,DEFV(CHAR,DTb0(fichier)));
/* Ou le mettre en memoire, */
DEFV(Argument,DEFV(Int,size_fichier));
/* Et taille en octets. */
DEFV(Argument,DEFV(Int,unite_fichier));
/* Nombre d'octets dans l'unite du fichier. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(PAS_D_ERREUR(Iload_fichier(nom_fichier,fichier,size_fichier,unite_fichier)))
/* On essaye de la recuperer, */
Bblock
CALS(Idelete_fichier(nom_fichier));
/* Et lorsque l'operation est couronnee de succes, on le detruit ensuite... */
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R D A N S L E P I P E S I L E N O M E S T */
/* V I D E O U S I N O N D A N S L E D I R E C T O R Y " i m a g e s " : */
/* */
/*************************************************************************************************************************************/
#define ISTORE_FICHIER(fichier,nom_fichier,size_fichier,unite_fichier,type_fichier) \
Bblock \
EQUIVALENCE_FICHIER(fichier,type_fichier); \
CODE_ERROR(Istore_fichier(ASD1(fichier_equivalent,fichier_non_type) \
,nom_fichier \
,INTE(size_fichier) \
,INTE(unite_fichier) \
) \
); \
Eblock \
/* Archivage d'un fichier de type donne. On notera l'introduction de : */ \
/* */ \
/* INTE(size_fichier) */ \
/* */ \
/* rendu obligatoire sur 'SYSTEME_SGPCM801_IRIX_CC' apres l'introduction de la version */ \
/* '600020000' de '$nC_RELEASE' qui, apparemment "caste" les 'size_fichier' a cause de */ \
/* l'utilisation de 'sizeof(...)' dans 'SIZE_GENERAL', ce "cast" etant apparemment */ \
/* incompatible avec le type attendu pour 'size_fichier' (soit 'Int'). */
BFonctionI
DEFV(Common,DEFV(FonctionI,Istore_fichier(fichier,nom_fichier,size_fichier,unite_fichier)))
DEFV(Argument,DEFV(CHAR,DTb0(fichier)));
/* Ou le prendre en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_fichier)));
/* Nom du fichier a ecrire (lorsque le nom est vide ("") on utilise un pipe), */
DEFV(Argument,DEFV(Int,size_fichier));
/* Et sa taille en octets. */
DEFV(Argument,DEFV(Int,unite_fichier));
/* Nombre d'octets dans l'unite du fichier. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(I3OU(IFEQ_chaine(nom_fichier,C_VIDE)
,IFEQ_chaine(nom_fichier,NOM_PIPE)
,IFEQ_chaine(nom_fichier,NOM_PIPE_Local)
)
)
Bblock
Test(IZEQ(OPEN_WRITE))
Bblock
PRINT_ERREUR("le test qui va suivre ne peut pas fonctionner correctement");
/* En effet le 'IZNE(ETLO(...,OPEN_WRITE))' qui va suivre sera toujours FAUX si */
/* 'OPEN_WRITE' est nul... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IZNE(ETLO(Fflags(STANDARD_OUT),OPEN_WRITE)))
/* Ce test a ete introduit le 20040913152923 car il manquait douloureusement. En effet, a */
/* cette date, il y a eu telle fausse manipulation faite sur '$LACT16' via la commande */
/* '$xci/passe_bande$X' a laquelle il manquait l'option "R=" ou un "pipe" ; cela a provoque */
/* l'envoi au '$CSH' de tres nombreuses commandes "esoteriques" (retrouvees dans l'history) */
/* et ce par un mecanisme qui m'echappe largement... */
/* */
/* Avant le 20040914090620, le test qui etait fait ici etait : */
/* */
/* IFEQ(Fflags(STANDARD_OUT),OPEN_WRITE) */
/* */
/* or sur des SYSTEMEs 'SYSTEME_APC_Linux', la reponse de 'Fflags(...)' peut eventuellement */
/* inclure plusieurs autres bits (c'est le cas ici en cas de redirection vers un fichier) ; */
/* d'ou cette nouvelle solution qui teste la presence du bit 'OPEN_WRITE' independamment des */
/* autres bits eventuels... */
Bblock
/* Cas ou une sortie "pipe" a ete demandee, alors qu'il semble y avoir un "pipe" en sortie */
/* (voir le fichier 'v $xtc/files.12$c' en ce qui concerne ce test...). */
CALS(Writ(STANDARD_OUT,fichier,size_fichier));
/* Ecriture sur la sortie standard lorsque le nom demande est vide ("") ; on pourra */
/* "piper" plusieurs programmes entre-eux. */
Eblock
ATes
Bblock
/* Cas ou une sortie "pipe" a ete demandee, alors qu'il ne semble pas y avoir de "pipe" en */
/* sortie, mais uniquement la "vraie" sortie standard... */
PRINT_ERREUR("le 'pipe' de sortie semble absent");
CODE_ERROR(ERREUR32);
/* Introduit le 20110224094715... */
Eblock
ETes
Eblock
ATes
Bblock
Test(IFEQ(PREMIER_CARACTERE_ITb0(nom_fichier)
,RACINE_DU_SYSTEME
)
)
/* Avant le 20060104171454, le test precedent etait : */
/* */
/* Test(IMEQ(PREMIER_CARACTERE_ITb0(nom_fichier) */
/* ,RACINE_DU_SYSTEME */
/* ,DIRECTORY_COURANT */
/* ) */
/* ) */
/* */
/* mais cela etait stupide car, en effet, des noms d'image ou de directory peuvent */
/* commencer par le caractere 'DIRECTORY_COURANT' (soit "."). Cela s'est vu lors d'un */
/* appel a 'v $xci/multi_02.04$K' avec un nom "R=" vide ; cela a alors cree trois */
/* images nom {$ROUGE,$VERTE,$BLEUE} dans le directory courant qui etait alors '$xci' */
/* ('v $Dhistory/LACT16$D/20060104172327 20060104130731')... */
Bblock
CODE_ERROR(Fstore_fichier_non_formatte(fichier
,nom_fichier
,size_fichier
,unite_fichier
,EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS
)
);
/* Tentative d'ouverture d'un fichier a l'aide d'un nom "absolu", lorsque */
/* le nom demande n'est pas vide et debute par le nom de la racine du systeme, */
/* ou par un nom "relatif" au directory courant si le nom debute par l'indicateur */
/* de directory courant... */
Eblock
ATes
Bblock
CODE_ERROR(Fstore_fichier_non_formatte(fichier
,NOM_FICHIER
,size_fichier
,unite_fichier
,EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS
)
);
/* Tentative d'ouverture d'un fichier a l'aide d'un nom "relatif" au directory "images" */
/* lorsque le nom demande n'est pas vide et ne debute pas par le nom de la racine */
/* du systeme. */
Eblock
ETes
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
#undef NOM_DU_FICHIER_D_UNE_COMMANDE_FICHIER
#undef INTRODUCTION_D_UNE_COMMANDE_FICHIER
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D E L ' E X I S T E N C E D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Itest_image(nom_image)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a tester. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CODE_ERROR(Itest_fichier(nom_image));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E S T R U C T I O N D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Idelete_image(nom_image)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CODE_ERROR(Idelete_fichier(nom_image));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N H I B I T I O N E V E N T U E L L E D E L A M A N I P U L A T I O N */
/* D E S C O M P O S A N T E S D ' U N E I M A G E E N C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP1_d_une_image_en_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP2_d_une_image_en_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP3_d_une_image_en_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
/* Afin d'inhiber, eventuellement, 'MANIPULATION_COMPOSANTE_OBJET_COULEURS(...)' pour un */
/* fichier de type "image". */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E S T R U C T I O N D ' U N E I M A G E E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_de_l_image,type_de_la_composante,espace_de_couleurs,detruire) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_l_image \
,type_de_la_composante \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Idelete_image(nom_composante_image));) \
,detruire \
); \
Eblock \
/* Tentative de destruction de la composante courante... */
DEFV(Common,DEFV(FonctionI,Idelete_image_en_couleurs(nom_image,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a detruire. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_image_en_couleurs
);
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_image_en_couleurs
);
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_image_en_couleurs
);
RETU_ERROR;
Eblock
#undef DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E N T A T I V E D E R E D I M E N S I O N N E M E N T : */
/* */
/*************************************************************************************************************************************/
#define BLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS(tenter_un_redimensionnement_en_cas_d_erreur) \
Bblock \
BSaveVariable(Logical,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers); \
/* Mis sous cette forme le 20101115154103... */ \
\
Test(I3OU(IFEQ_chaine(nom_image,C_VIDE) \
,IFEQ_chaine(nom_image,NOM_PIPE) \
,IFEQ_chaine(nom_image,NOM_PIPE_Local) \
) \
) \
Bblock \
Eblock \
ATes \
Bblock \
Test(IL_FAUT(tenter_un_redimensionnement_en_cas_d_erreur)) \
Bblock \
EGAL(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers,FAUX); \
/* Afin de bloquer les messages d'erreur du premier 'ILOAD_FICHIER_AVEC_CONVERSION(...)' */ \
/* ci-apres car, en effet, ils peuvent disparaitre avec le redimensionnement. Dans le */ \
/* cas ou ces messages ne seraient pas lies a la taille (par exemple : fichier inexistant), */ \
/* ils apparaitront lors du second 'ILOAD_FICHIER_AVEC_CONVERSION(...)' qui est effectue */ \
/* dans 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' (introduit le 20090422094437). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
/* Le 'Eblock' absent est dans 'DEBLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS' et */ \
/* ce a cause de 'BSaveVariable(...)'. */ \
/* */ \
/* Cette procedure a ete introduite le 20090422094437... */
#define DEBLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS \
/* Le 'Bblock' absent est dans 'BLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS(...)' et */ \
/* ce a cause de 'ESaveVariable(...)'. */ \
ESaveVariable(Logical,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers); \
/* Mis sous cette forme le 20101115154103... */ \
Eblock \
/* Introduit le 20090422094437... */
#define SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(type_image,taille_element) \
CAse(SCAL(GvalDefaut("taille_ ## type_image",TAILLE_D_UN_FICHIER_IMAGE(dimXY,taille_element)) \
,size_p \
,taille_element \
) \
) \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_reconnu),"type_image")); \
EGAp(format_de_imageR,chain_Acopie(format_reconnu)); \
/* Introduit le 20090422104212... */ \
\
EGAL(le_redimensionnement_est_possible,VRAI); \
/* Le redimensionnement est possible (introduit le 20090420083748). */ \
\
SET_DIMENSIONS_2D_SANS_VALIDATION(GvalDefaut("Xmin ## type_image",Xmin) \
,GvalDefaut("Xmax ## type_image",Xmax) \
,GvalDefaut("Ymin ## type_image",Ymin) \
,GvalDefaut("Ymax ## type_image",Ymax) \
); \
/* On fait l'hypothese d'une image de type 'type_image'... */ \
Eblock \
ECAs \
/* Introduit le 20090419081339 pour simplifier 'TENTATIVE_DE_REDIMENSIONNEMENT(...)'. */
#define TENTATIVE_DE_REDIMENSIONNEMENT(forcer,tenter,methode_de_redimensionnement,sequence,taille_element,avertir) \
Bblock \
Test(IFOU(IL_FAUT(forcer) \
,IL_FAUT(tenter) \
) \
) \
/* Cette possibilite fut introduite le 20080916174109 et ce test mis a l'entree de la */ \
/* procedure 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' au lieu de l'exterieur le 20090502100857. */ \
/* */ \
/* Le forcage de redimensionnement a ete introduit le 20090502093317 pour prendre en */ \
/* compte le cas des formats qui sont differents (au niveau 'dimX' et 'dimY') mais qui */ \
/* correspondent a des 'dimXY' identiques (et donc a des tailles de fichiers identiques). */ \
/* C'est par exemple le cas des "anti-formats"s : ainsi une image 575x780 ('anti-Pal') */ \
/* a meme taille (448500) qu'une image 780x575 ('Pal'), les dimensions en 'X' et en 'Y' */ \
/* etant permutees. Dans un tel cas la taille 'taille_de_imageR' est de 448500 dans les */ \
/* deux cas. Lors du chargement d'une image au format 'anti-Pal', il n'y a pas d'erreur dans */ \
/* 'ILOAD_FICHIER_AVEC_CONVERSION(...)' et le test 'IL_Y_A_ERREUR(CODE_ERREUR)' qui suit */ \
/* est 'FAUX' : la procedure 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' n'est donc pas appelee. */ \
/* Il faut donc pouvoir dans de tels cas forcer le redimensionnement... */ \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_de_imageR),CHAINE_UNDEF)); \
/* Afin de pouvoir editer 'type_image' s'il est reconnu... */ \
DEFV(Logical,INIT(le_redimensionnement_est_possible,LUNDEF)); \
/* Afin de controler le redimensionnement... */ \
DEFV(Int,INIT(taille_de_imageR,Isize_image(nom_image))); \
/* La taille de 'imageR' va permettre de selectionner, si possible, un format d'image */ \
/* de base... */ \
/* */ \
/* On rappelle le 20090420172620 que si 'nom_image' est {C_VIDE,NOM_PIPE,NOM_PIPE_Local} */ \
/* alors 'Isize_image(...)' renvoie la valeur 'TAILLE_RENVOYEE_POUR_UN_PIPE' (soit -1), */ \
/* mais que cela ne peut jamais se rencontrer ici puisque les cas precedents sont testes */ \
/* et elimines avant chaque appel a 'TENTATIVE_DE_REDIMENSIONNEMENT(...)'. */ \
\
DEFV(Int,INIT(CODE_ERREUR_avant_la_tentative_de_redimensionnement,CODE_ERREUR)); \
/* Sauvegarde du code d'erreur precedent... */ \
/* */ \
/* On notera le 20101115154103 que l'on ne peut pas utiliser 'BSaveModifyVariable(..)' */ \
/* car le 'ESaveModifyVariable(...)' ne serait pas au meme niveau {Bblock,...,Eblock}... */ \
EGAL(CODE_ERREUR,OK); \
/* A priori... */ \
\
PUSH_DIMENSIONS_2D; \
\
CHoi(taille_de_imageR) \
Bblock \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT1,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT2,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT3,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT4,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT5,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT6,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT7,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT8,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(FIT9,taille_element); \
/* A compter du 20090501102312 on teste d'abord quelques "Formats d'Image Temporaires" */ \
/* ('v $Fimages gFITn' en ce qui concerne leur definition...). */ \
/* */ \
/* On notera au passage qu'a cette date j'ai fait des experiences pour voir s'il etait */ \
/* possible de factoriser 'taille_de_imageR' ('v $xtc/f_tailleI.02$c') sous la forme */ \
/* 'dimX.dimY'. Malheureusement, il y a en general ambiguite, d'ou la non implementation */ \
/* de ce dispositif. Malgre tout, le 20090503100611 j'ai introduit dans le programme de */ \
/* test 'v $xtc/f_tailleI.02$c 20090503100611' un dispositif de rapport 'dimX/dimY' le */ \
/* plus proche recherche ("Best"). Du coup, une implementation devient envisageable, */ \
/* mais est-ce d'une quelconque utilite (surtout depuis l'introduction des 'FITn's...) ? */ \
/* Le 20090504100401 fut introduit la commande 'v $xcg/dimX_dimY$vv$K' qui permet de lister */ \
/* les meilleurs factorisation, au cas ou... */ \
/* */ \
/* Le 20090502093745 le test des "Formats d'Image Temporaires" a ete place avant celui */ \
/* des formats de base afin de pouvoir traiter des cas tels celui du format 'anti-Pal' */ \
/* (448500=575x780) qui ressemble au 'Pal' (448500=780x575) mais qui ne doit pas etre */ \
/* confondu avec ce dernier, evidemment ! On n'oubliera pas alors, qu'etant donne que */ \
/* la discrimination des formats se fait uniquement par la taille des fichiers, il est */ \
/* imperatif de forcer le redimensionnement... */ \
\
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Sus,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Pus,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Suh,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Puh,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Suq,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Puq,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Sud,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Pud,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Std,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Pal,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Sdu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Pdu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Squ,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Pqu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Shu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Phu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Ssu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Psu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Stu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(Ptu,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(TvA,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(TvB,taille_element); \
SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT(TvC,taille_element); \
/* Puis, on fait l'hypothese de l'un des formats de base (classes ci-dessus par ordre de */ \
/* '$taille_???' croissantes). */ \
/* */ \
/* Les formats {Ssu,Psu,Stu,Ptu} ont ete introduits le 20150213114602... */ \
/* */ \
/* Les formats {Sus,Pus} ont ete introduits le 20150929105940... */ \
/* */ \
/* Les formats {TvA,TvB,TvC} ont ete introduits le 20240608141156... */ \
\
DEfo \
Bblock \
EGAL(le_redimensionnement_est_possible,FAUX); \
/* Aucun format d'image n'a ete trouve : le redimensionnement est donc impossible... */ \
Eblock \
EDEf \
Eblock \
ECHo \
\
Test(EST_VRAI(le_redimensionnement_est_possible)) \
Bblock \
Test(IFOU(IFOU(IFNE(Xmin,EnTete_de_sauvegardM ## Xmin) \
,IFNE(Xmax,EnTete_de_sauvegardM ## Xmax) \
) \
,IFOU(IFNE(Ymin,EnTete_de_sauvegardM ## Ymin) \
,IFNE(Ymax,EnTete_de_sauvegardM ## Ymax) \
) \
) \
) \
Bblock \
/* Ce test a ete introduit le 20090502093745 lors de l'introduction du forcage de */ \
/* redimensionnement. En effet ce forcage est necessaire dans le cas, par exemple, d'une */ \
/* image au format 'anti-Pal' (448500=575x780) qui ressemble au 'Pal' (448500=780x575). */ \
/* Par contre une image au format 'Pal' n'aura pas a etre redimensionnee... */ \
Test(IL_FAUT(avertir)) \
Bblock \
/* Test introduit le 20090422092530... */ \
MESSAGES_DES_FICHIERS(Prer3("Redimensionnement (methode '%d') de l'image '%s' (format '%s').\n" \
,methode_de_redimensionnement \
,nom_image \
,format_de_imageR \
) \
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
BLOC(sequence); \
/* Le redimensionnement peut etre tente... */ \
Eblock \
ATes \
Bblock \
/* Evidemment, lorsque les axes en 'X' et 'Y' n'ont pas change, il est inutile d'executer */ \
/* la sequence 'sequence' de redimensionnement... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
MESSAGES_DES_FICHIERS(Prer2("Le redimensionnement a echoue (taille (%d) du fichier '%s' non reconnue).\n" \
,taille_de_imageR \
,nom_image \
) \
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers \
); \
/* L'edition de 'nom_image' a ete introduite le 20090511181911... */ \
EGAL(CODE_ERREUR,CODE_ERREUR_avant_la_tentative_de_redimensionnement); \
/* Restauration du code d'erreur precedent... */ \
/* */ \
/* On notera le 20101115154103 que l'on ne peut pas utiliser 'ESaveModifyVariable(..)' */ \
/* car le 'BSaveModifyVariable(...)' ne serait pas au meme niveau {Bblock,...,Eblock}... */ \
Eblock \
ETes \
\
PULL_DIMENSIONS_2D; \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Tentative de redimensionnement d'une image (introduite le 20090418182008). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(Iload_image_____permuter_les_bits_de_l_image,FAUX)));
DEFV(Common,DEFV(Positive,SINT(Iload_image_____taille_des_paquets_de_bits,TAILLE_PAR_DEFAUT_DES_PAQUETS_DE_PERMUTATION_DES_BITS)));
DEFV(Common,DEFV(Int,SINT(Iload_image_____translation_des_index_de_bits,TRANSLATION_PAR_DEFAUT_DES_INDEX_DE_BITS)));
/* Parametrage de 'Iload_image(...)' introduit le 20130707181804... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____un_nom_absent_est_une_erreur,VRAI)));
/* Cet indicateur indique si un nom vide est une erreur (introduit le 20080212093518), */
/* dans le cas contraire 'Iload_image_____valeur_initiale_si_erreur' est la valeur donnee */
/* a chaque element du fichier... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____tenter_une_conversion_standard_en_cas_d_erreur,FAUX)));
/* En cas d'erreur de lecture en mode 'fichier_type_image', cet indicateur permet */
/* d'autoriser une tentative de lecture en mode 'fichier_type_imageF'. Cette possibilite */
/* fut introduite le 20080916174109... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____faire_la_conversion_standard_avec_renormalisation,VRAI)));
/* Losrqu'il y a conversion, elle peut se faire avec renormalisation ('VRAI') ou bien */
/* brutalement ('FAUX'). Cette possibilite fut introduite le 20080917104205... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur,FAUX)));
DEFV(Common,DEFV(Logical,SINT(Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur,FAUX)));
DEFV(Common,DEFV(Int,SINT(Iload_image_____methode_de_redimensionnement_a_utiliser,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE)));
DEFV(Common,DEFV(Logical,SINT(Iload_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur,FAUX)));
/* En cas d'erreur de lecture en mode 'fichier_type_image', cet indicateur permet de */
/* tenter un redimensionnement suivant une certaine methode (introduit le 20090418182008 */
/* et complete le 20090422092530). */
/* */
/* Le forcage de redimensionnement a ete introduit le 20090502093317 pour prendre en */
/* compte le cas des formats qui sont differents (au niveau 'dimX' et 'dimY') mais qui */
/* correspondent a des 'dimXY' identiques (et donc a des tailles de fichiers identiques). */
/* C'est par exemple le cas des "anti-formats"s : ainsi une image 575x780 ('anti-Pal') */
/* a meme taille (448500) qu'une image 780x575 ('Pal'), les dimensions en 'X' et en 'Y' */
/* etant permutees. Dans un tel cas la taille 'taille_de_imageR' est de 448500 dans les */
/* deux cas. Lors du chargement d'une image au format 'anti-Pal', il n'y a pas d'erreur dans */
/* 'ILOAD_FICHIER_AVEC_CONVERSION(...)' et le test 'IL_Y_A_ERREUR(CODE_ERREUR)' qui suit */
/* est 'FAUX' : la procedure 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' n'est donc pas appelee. */
/* Il faut donc pouvoir dans de tels cas forcer le redimensionnement... */
/* */
/* En ce qui concerne la methode de redimensionnement a utiliser, toutes celles qui sont */
/* disponibles dans 'v $xiii/di_image$DEF types_de_methode_de_redimensionnement' sont */
/* utilisables ici... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____tenter_les_conversions_de_nom,TENTER_LES_CONVERSIONS_DANS_Iload_image)));
/* Cet indicateur indique si les noms qui ressemblent a des valeurs numeriques peuvent etre */
/* utilises comme valeur de tous les points de l'image... */
DEFV(Common,DEFV(genere_p,SINT(Iload_image_____valeur_initiale_si_erreur,NOIR)));
/* Valeur a donner a 'imageR' si l'image 'nom_image' n'existe pas (parametre introduit */
/* le 20021004150125) ou si le nom est absent sans que cela soit une erreur... */
DEFV(Common,DEFV(Logical,SINT(Iload_image_____initialiser_en_cas_d_erreur_fichier,VRAI)));
/* Introduit le 20101118103438 pour controler l'initialisation de 'imageR' s'il y a un */
/* probleme avec le fichier 'nom_image'. Cela est tres utile dans le programme */
/* 'v $xci/sequence$K Iload_image_____initialiser_en_cas_d_erreur_fichier' pour */
/* permettre un reaffichage correct de l'image precedente dans le cas ou l'image */
/* courante n'existe pas (ou pas encore...). */
DEFV(Common,DEFV(FonctionI,Iload_image(imageR,nom_image)))
DEFV(Argument,DEFV(image,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
BLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS(Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur);
/* Introduit le 20090422094437... */
ILOAD_FICHIER_AVEC_CONVERSION(nom_image,imageR,size_i,size_p,fichier_type_image
,Iload_image_____tenter_les_conversions_de_nom,genere_p,genp
,Iinitialisation
,Iload_image_____initialiser_en_cas_d_erreur_fichier
,Iload_image_____valeur_initiale_si_erreur
,Iload_image_____un_nom_absent_est_une_erreur
);
/* Tentative de chargement "simple" de l'image a priori... */
/* */
/* On notera que l'on ne place pas ce 'ILOAD_FICHIER_AVEC_CONVERSION(...)' apres le 'ATes' */
/* du 'Test(IL_FAUT(Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur)' (en */
/* supprimant le 'Test(IL_Y_A_ERREUR(CODE_ERREUR))' suivant evidemment...) afin de */
/* simplifier 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' et faire ainsi en sorte qu'il n'y */
/* ait pas de 'Iredimensionnement(...)' s'il n'est pas utile (lorsque 'taille_de_imageR' */
/* est egal a 'TAILLE_D_UN_FICHIER_IMAGE(dimXY,size_p)'). */
DEBLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS;
/* Introduit le 20090422094437... */
Test(I3OU(IFEQ_chaine(nom_image,C_VIDE)
,IFEQ_chaine(nom_image,NOM_PIPE)
,IFEQ_chaine(nom_image,NOM_PIPE_Local)
)
)
Bblock
/* Lorsque 'nom_image' est {C_VIDE,NOM_PIPE,NOM_PIPE_Local}, il est impossible de refaire */
/* des 'ILOAD_FICHIER_AVEC_CONVERSION(...)'s car, en effet, 'Iload_fichier(...)' a deja */
/* "epuise" le "pipe" d'entree dans le 'ILOAD_FICHIER_AVEC_CONVERSION(...)' qui precede... */
/* Ce test a donc ete introduit le 20090420172620 car il manquait... */
Eblock
ATes
Bblock
Test(IFOU(IL_Y_A_ERREUR(CODE_ERREUR)
,IL_FAUT(Iload_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur)
)
)
Bblock
#define METHODE_DE_REDIMENSIONNEMENT_A_UTILISER \
Iload_image_____methode_de_redimensionnement_a_utiliser \
/* Pour raccourcir une des lignes suivantes... */
TENTATIVE_DE_REDIMENSIONNEMENT(Iload_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur
,Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
,BLOC(
Bblock
BDEFV(image,imageR_mal_dimensionnee);
ILOAD_FICHIER_AVEC_CONVERSION(nom_image
,imageR_mal_dimensionnee
,size_i
,size_p
,fichier_type_image
,Iload_image_____tenter_les_conversions_de_nom
,genere_p
,genp
,Iinitialisation
,Iload_image_____initialiser_en_cas_d_erreur_fichier
,Iload_image_____valeur_initiale_si_erreur
,Iload_image_____un_nom_absent_est_une_erreur
);
/* Tentative de rechargement de l'image 'nom_image', mais en ayant mis en place ses */
/* possibles dimensions {{Xmin,Xmax},{Ymin,Ymax}}. */
CALS(Iredimensionnement(imageR
,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax
,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax
,imageR_mal_dimensionnee
,Xmin,Xmax,Ymin,Ymax
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
)
);
/* Redimensionnement... */
EDEFV(image,imageR_mal_dimensionnee);
Eblock
)
,size_p
,Iload_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur
);
#undef METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
Test(IL_Y_A_ERREUR(CODE_ERREUR))
Bblock
Test(IL_FAUT(Iload_image_____tenter_une_conversion_standard_en_cas_d_erreur))
/* Cette possibilite fut introduite le 20080916174109... */
Bblock
BDEFV(imageF,imageR_flottante);
/* Image de type 'genere_Float' que l'on va tenter de lire, puis convertir... */
EGAL(CODE_ERREUR,OK);
/* A priori... */
MESSAGES_DES_FICHIERS(Prer2("Une lecture 'standard=%s' et une conversion 'standard=%s' vont etre tentees.\n"
,C_FAUX____
,C_VRAI____
)
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
);
ILOAD_FICHIER_AVEC_CONVERSION(nom_image
,imageR_flottante
,size_iF
,size_Float
,fichier_type_imageF
,Iload_image_____tenter_les_conversions_de_nom
,genere_Float
,flot
,IFinitialisation
,Iload_image_____initialiser_en_cas_d_erreur_fichier
,FLOT(Iload_image_____valeur_initiale_si_erreur)
,Iload_image_____un_nom_absent_est_une_erreur
);
/* Tentative de lecture de 'imageR' en mode "flottant"... */
Test(IL_FAUT(Iload_image_____faire_la_conversion_standard_avec_renormalisation))
Bblock
CALS(Ifloat_std_avec_renormalisation(imageR,imageR_flottante));
Eblock
ATes
Bblock
CALS(Ifloat_std_brutal(imageR,imageR_flottante));
Eblock
ETes
/* Et conversion qu'il n'y ait pas eu d'erreur ou qu'il y en ait eu une. En effet, dans ce */
/* dernier cas 'ILOAD_FICHIER_AVEC_CONVERSION(...)' procede a une initialisation... */
/* */
/* Le 20080917104205, la fonction 'Ifloat_std(...)' a ete remplacee par un choix entre */
/* 'Ifloat_std_avec_renormalisation(...)' et 'Ifloat_std_brutal(...)' qui sont plus souples */
/* et plus simples a utiliser (les extrema de 'imageR_flottante' ne sont pas a connaitre). */
EDEFV(imageF,imageR_flottante);
/* Image de type 'genere_Float' que l'on va tenter de lire, puis convertir... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(IL_FAUT(Iload_image_____permuter_les_bits_de_l_image))
/* Possibilite introduite le 20130707181804... */
/* */
/* Cela permet de "mimer" la gestion d'images de type "bits" (et non plus d'"octets"). En */
/* effet, on vient de ci-dessus de recuperer une image, mais dont les bits sont "classes" */
/* plan par plan. Si '..._____translation_des_index_de_bits' est nul, alors on trouve en */
/* tete du fichier les bits de poids le plus fort (2^7), puis 2^6,..., jusqu'a 2^0. En */
/* donnant a '..._____translation_des_index_de_bits' une valeur differente, on peut */
/* ainsi selectionner le plan de bit qui se trouve en tete... */
Bblock
BDEFV(image,imageR_permutee);
BSaveModifyVariable(Int
,Ipermutation_inverse_de_regroupement_des_bits_de_meme_poids_____taille_des_paquets_de_bits
,Iload_image_____taille_des_paquets_de_bits
);
BSaveModifyVariable(Int
,Ipermutation_inverse_de_regroupement_des_bits_de_meme_poids_____translation_des_index_de_bits
,Iload_image_____translation_des_index_de_bits
);
/* Parametrage de la permutation inverse... */
CALi(Imove(imageR_permutee,imageR));
CALi(Ipermutation_inverse_de_regroupement_des_bits_de_meme_poids(imageR,imageR_permutee));
/* Permutation inverse... */
ESaveModifyVariable(Int
,Ipermutation_inverse_de_regroupement_des_bits_de_meme_poids_____translation_des_index_de_bits
);
ESaveModifyVariable(Int
,Ipermutation_inverse_de_regroupement_des_bits_de_meme_poids_____taille_des_paquets_de_bits
);
EDEFV(image,imageR_permutee);
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " S T A N D A R D " S I P R E S E N T : */
/* */
/*************************************************************************************************************************************/
#define ILOAD_IMAGE_SI_PRESENT(imageR,nom_image,nom_image_absent,valeur_par_defaut,fonction_load,fonction_initialisation) \
Bblock \
Test(IFNE_chaine(nom_image,nom_image_absent)) \
Bblock \
CODE_ERROR(fonction_load(imageR,nom_image)); \
/* Cas ou 'nom_image' est significatif... */ \
Eblock \
ATes \
Bblock \
CALS(fonction_initialisation(imageR,valeur_par_defaut)); \
/* Cas ou 'nom_image' est absent, on initialise avec la valeur par defaut... */ \
Eblock \
ETes \
Eblock \
/* Chargement ou initialisation d'une image (introduit le 20041230221011)... */
BFonctionI
DEFV(Common,DEFV(FonctionI,Iload_image_si_present(imageR,nom_image,nom_image_absent,valeur_par_defaut)))
/* Fonction introduite le 20041230213528... */
DEFV(Argument,DEFV(image,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
DEFV(Argument,DEFV(CHAR,DTb0(nom_image_absent)));
/* Nom de l'image "standard" a lire et nom au cas ou il n'y a pas de nom... */
DEFV(Argument,DEFV(genere_p,valeur_par_defaut));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_IMAGE_SI_PRESENT(imageR,nom_image,nom_image_absent,valeur_par_defaut,Iload_image,Iinitialisation);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " S T A N D A R D " */
/* A V E C R E D I M E N S I O N N E M E N T E V E N T U E L : */
/* */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * ** * * * * * ** * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * ** * * * * * ** */
/* * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* */
/* ATTENTION : */
/* */
/* Dans l'etat actuel, cette fonction est */
/* d'une realisation tres delicate. En effet, */
/* lors de l'entree dans le programme 'Main(...)' */
/* toutes les variables sont initialisees, soit */
/* dans des declarations du type : */
/* */
/* DEFV(...,INIT(...,...)); */
/* */
/* soit dans des initialisation du type : */
/* */
/* INITIALISATION_...(...); */
/* */
/* Ainsi, a chaque "rerentree," il est essentiel que */
/* toutes ne reprennent pas leurs valeurs implicites */
/* (ou "par defaut"). Un indicateur est introduit */
/* ('Iload_image_avec_redimensionnement_eventuel_____le_redimensionnement_est_activable') */
/* afin de pouvoir inhiber ce dispositif sans modifier */
/* les commandes qui le reference deja... */
/* */
/* */
/* Nota : */
/* */
/* Suite a l'introduction de la procedure */
/* 'v $xiii/files$FON TENTATIVE_DE_REDIMENSIONNEMENT', */
/* la fonction 'Iload_image_avec_redimensionnement_eventuel(...)' */
/* n'a en fait plus aucun interet, mais on la laisse, on ne sait */
/* jamais... */
/* */
/* En fait, je note le 20130909110821 que cette fonction est utilisee */
/* dans 'v $xci/display$K Iload_image_avec_redimensionnement_eventuel' */
/* et dans 'v $xci/animation$K Iload_image_avec_redimensionnement_eventuel' */
/* et n'est donc pas si inutile que cela... */
/* */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(Iload_image_avec_redimensionnement_eventuel_____le_redimensionnement_est_activable,FAUX)));
/* Afin d'inhiber brutalement ce dispositif. ATTENTION, jusqu'au 20000801110904, cet */
/* indicateur etait 'Local', mais il semble qu'il doive etre 'Common' afin de pouvoir */
/* etre manipule depuis n'importe quel programme '$K'... */
/* */
/* Suite a l'introduction de 'v $xiii/files$FON TENTATIVE_DE_REDIMENSIONNEMENT', le */
/* 20080916174109, cet indicateur est passe de 'VRAI' a 'FAUX' le 20090604090257, etant */
/* devenu en fait inutile, mais etant conserve car, en effet, on ne sait jamais... */
DEFV(Ailleurs,DEFV(FonctionI,Main()));
/* Point de rerentree dans la commande courante... */
DEFV(Common,DEFV(FonctionI,Iload_image_avec_redimensionnement_eventuel(imageR,nom_image
,tenter_un_redimensionnement
,nombre_d_arguments,arguments
)
)
)
DEFV(Argument,DEFV(image,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a lire. */
DEFV(Argument,DEFV(Logical,tenter_un_redimensionnement));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') tenter le redimensionnement... */
DEFV(Argument,DEFV(Int,nombre_d_arguments));
/* Nombre d'arguments recus par la commande courante, y compris son nom. */
DEFV(Argument,DEFV(CHAR,POINTERc(DTb0(arguments))));
/* Liste des arguments recus par la commande courante, y compris son nom. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(IFET(EST_VRAI(Iload_image_avec_redimensionnement_eventuel_____le_redimensionnement_est_activable)
,IL_FAUT(tenter_un_redimensionnement)
)
)
Bblock
DEFV(Int,INIT(taille_reelle_de_l_image,UNDEF));
/* Taille reelle de l'image en octets... */
/* */
/* ATTENTION, a cause de 'TAILLE_RENVOYEE_POUR_UN_PIPE', la taille ne peut etre un */
/* 'Positive' et donc doit etre obligatoirement un 'Int'. Une autre raison (introduite */
/* le 20060910101623) est que 'Isize_fichier(...)' utilise 'TAILLE_D_UNE_IMAGE_UNDEF' qui */
/* est defini via un 'NEGA(...)' ('v $xiii/files$DEF TAILLE_D_UNE_IMAGE_UNDEF'). */
CALS(Isize_fichier(nom_image,ADRESSE(taille_reelle_de_l_image)));
/* Taille reelle de l'image en octets... */
Test(IFNE(taille_reelle_de_l_image,TAILLE_RENVOYEE_POUR_UN_PIPE))
Bblock
Test(IFNE(taille_reelle_de_l_image,size_i))
Bblock
/* Cas ou le fichier n'a pas la taille attendu : */
DEFV(Logical,INIT(le_redimensionnement_peut_etre_tente,FAUX));
/* Indicateur precisant si le redimensionnement peut etre tente ('VRAI') ou pas ('FAUX'), */
/* le choix dependant de la taille reelle... */
CHoi(taille_reelle_de_l_image)
/* En executant le programme 'v $xtc/factorise.01$c' (ou 'v $xcg/factorise.01$X'), on verra */
/* que malheureusement, en ce qui concerne, par exemple, les images 'Pal', il existe */
/* plusieurs factorisations de la taille qui sont raisonnables (c'est-a-dire en excluant */
/* par exemple 1x448500) : */
/* */
/* 448500 = 650x690 */
/* 448500 = 598x750 */
/* 448500 = 575x780 */
/* 448500 = 500x897 */
/* 448500 = 460x975 */
/* */
/* cela empeche donc de faire une factorisation automatique du type 'dimX*dimY'... */
/* */
/* ATTENTION, on notera que l'on n'utilise pas : */
/* */
/* Choi(...) */
/* Bblock */
/* Ca1e(...) */
/* Bblock */
/* Eblock */
/* ECa1 */
/* */
/* Defo(...) */
/* Bblock */
/* Eblock */
/* EDef */
/* Eblock */
/* ECho */
/* */
/* car, en effet, la constante 'TAILLE_D_UNE_IMAGE_STANDARD_Pal' peut, suivant la MACHINE */
/* sur laquelle on se trouve, faire appel a la fonction 'Gval(...)' via les definitions */
/* de 'dimXPali' et 'dimYPali'... */
Bblock
CAse(TAILLE_D_UNE_IMAGE_STANDARD_Std)
Bblock
Test(IL_FAUT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers))
Bblock
PRINT_ATTENTION("le format courant est incompatible avec l'image, qui est au format 'Std'");
Eblock
ATes
Bblock
Eblock
ETes
SET_DIMENSIONS_2D_SANS_VALIDATION(k___Xmin,k___Xmax,k___Ymin,k___Ymax);
/* Et tentative de forcage du format 'Std'. On notera l'utilisation de la procedure */
/* 'SET_DIMENSIONS_2D_SANS_VALIDATION(...)' et non pas 'SET_DIMENSIONS_2D(...)', et ce */
/* afin de ne pas avoir 'AVERTISSEMENT_SUR_LE_NON_REDIMENSIONNEMENT_DE_CERTAINES_IMAGES'... */
EGAL(le_redimensionnement_peut_etre_tente,VRAI);
/* Le redimensionnement peut etre tente... */
Eblock
ECAs
#ifdef TAILLE_D_UNE_IMAGE_STANDARD_Pal
/* ATTENTION, 'TAILLE_D_UNE_IMAGE_STANDARD_Pal' n'est defini que si 'dimXYPali' est lui-meme */
/* defini ('v $xiidG/fonction.1$DEF TAILLE_D_UNE_IMAGE_STANDARD_Pal'), or 'dimXYPali' n'est */
/* lui-meme defini ('v $xiidG/fonction.1$DEF dimXYPali') que si l'option de compilation */
/* '__VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS' l'est ; ce n'est, par exemple, pas */
/* le cas sur '$LACT29'... */
CAse(TAILLE_D_UNE_IMAGE_STANDARD_Pal)
Bblock
Test(IL_FAUT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers))
Bblock
PRINT_ATTENTION("le format courant est incompatible avec l'image, qui est au format 'Pal'");
Eblock
ATes
Bblock
Eblock
ETes
SET_DIMENSIONS_2D_SANS_VALIDATION(XminPali,XmaxPali,YminPali,YmaxPali);
/* Et tentative de forcage du format 'Pal'. On notera l'utilisation de la procedure */
/* 'SET_DIMENSIONS_2D_SANS_VALIDATION(...)' et non pas 'SET_DIMENSIONS_2D(...)', et ce */
/* afin de ne pas avoir 'AVERTISSEMENT_SUR_LE_NON_REDIMENSIONNEMENT_DE_CERTAINES_IMAGES'... */
EGAL(le_redimensionnement_peut_etre_tente,VRAI);
/* Le redimensionnement peut etre tente... */
Eblock
ECAs
#Aifdef TAILLE_D_UNE_IMAGE_STANDARD_Pal
#Eifdef TAILLE_D_UNE_IMAGE_STANDARD_Pal
DEfo
Bblock
/* Pour les autres formats, on ne fait rien... */
Test(IL_FAUT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers))
Bblock
PRINT_ATTENTION("le format courant est incompatible avec l'image, et n'est pas reconnu");
/* ATTENTION, voir le commentaire relatif a 'TAILLE_D_UNE_IMAGE_STANDARD_Pal' ci-dessus... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDEf
Eblock
ECHo
Test(EST_VRAI(le_redimensionnement_peut_etre_tente))
Bblock
/* La sequence qui suit est inspiree du programme 'v $xtc/goto.01$c'. */
INCR(programme_principal_____indicateur_de_rerentree,I);
/* Mise a jour de l'indicateur de "rerentree" dans le programme principal... */
CODE_ERROR(Main(nombre_d_arguments,arguments));
/* Lorsque le redimensionnement peut etre tente, on rerentre dans le programme principal. */
/* On notera que tous les arguments ne seront pas reinterpretes malgre ce que laisserait */
/* supposer l'appel ci-dessus (voir 'v $xig/fonct$vv$DEF'). */
Exit(CODE_ERREUR);
/* Et on sort ; en effet, sinon, l'execution de la fonction courante reprendrait, et on */
/* reviendrait dans le programme principal que l'on vient donc d'executer... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou le fichier a bien la taille attendue... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
CODE_ERROR(Iload_image(imageR,nom_image));
/* Et enfin, realisation de la lecture effective... */
RETU_ERROR;
Eblock
EFonctionI
#undef TAILLE_RENVOYEE_POUR_UN_PIPE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N E I M A G E E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define ACCES_A_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(imageR,nom_de_l_image,type_de_la_composante,espace_de_couleurs,acceder) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_l_image \
,type_de_la_composante \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Iload_image(imageR \
,nom_composante_image \
) \
); \
) \
,acceder \
); \
Eblock \
/* Tentative d'acces a la composante courante... */
DEFV(Common,DEFV(FonctionI,Iload_image_en_couleurs(imageR_COMP1,imageR_COMP2,imageR_COMP3,nom_image,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(image,imageR_COMP1));
DEFV(Argument,DEFV(image,imageR_COMP2));
DEFV(Argument,DEFV(image,imageR_COMP3));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a acceder. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ACCES_A_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(imageR_COMP1
,nom_image
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_image_en_couleurs
);
ACCES_A_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(imageR_COMP2
,nom_image
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_image_en_couleurs
);
ACCES_A_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(imageR_COMP3
,nom_image
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_image_en_couleurs
);
RETU_ERROR;
Eblock
#undef ACCES_A_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " S T A N D A R D " */
/* S O U S L A F O R M E D ' U N P O I N T E U R : */
/* */
/*************************************************************************************************************************************/
BFonctionP
DEFV(Common,DEFV(Logical,SINT(Iacces_image_____un_nom_absent_est_une_erreur,VRAI)));
/* Cet indicateur indique si un nom vide est une erreur (introduit le 20080212093518), */
/* dans le cas contraire 'Iacces_image_____valeur_initiale_si_erreur' est la valeur donnee */
/* a chaque element du fichier... */
DEFV(Common,DEFV(Logical,SINT(Iacces_image_____tenter_les_conversions_de_nom,TENTER_LES_CONVERSIONS_DANS_Iacces_image)));
/* Cet indicateur indique si les noms qui ressemblent a des valeurs numeriques peuvent etre */
/* utilises comme valeur de tous les points de l'image... */
DEFV(Common,DEFV(genere_p,SINT(Iacces_image_____valeur_initiale_si_erreur,NOIR)));
/* Valeur a donner a 'imageR' si l'image 'nom_image' n'existe pas (parametre introduit */
/* le 20021004150125) ou si le nom est absent sans que cela soit une erreur... */
DEFV(Common,DEFV(Logical,SINT(Iacces_image_____initialiser_en_cas_d_erreur_fichier,VRAI)));
/* Introduit le 20101118103438 pour controler l'initialisation de 'imageR' s'il y a un */
/* probleme avec le fichier 'nom_image'... */
DEFV(Common,DEFV(FonctionP,POINTERp(Iacces_image(imageR,nom_image))))
DEFV(Argument,DEFV(image,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AVEC_CONVERSION(nom_image,imageR,size_i,size_p,fichier_type_image
,Iacces_image_____tenter_les_conversions_de_nom,genere_p,genp
,Iinitialisation
,Iacces_image_____initialiser_en_cas_d_erreur_fichier
,Iacces_image_____valeur_initiale_si_erreur
,Iacces_image_____un_nom_absent_est_une_erreur
);
/* On notera le 20090423145235 que la fonction 'Iacces_image(...)' est beaucoup moins */
/* "puissante" que la fonction 'Iload_image(...)' car, en effet, contrairement a cette */
/* derniere, elle ne permet pas le redimensionnement. De plus, il n'est pas possible de */
/* definir simplement 'Iacces_image(...)' avec 'Iload_image(...)' a cause des nombreuses */
/* variables de controle 'Iacces_image_____...' et 'Iload_image_____...'. */
RETI(imageR);
Eblock
EFonctionP
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " C H A R " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadC_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageC,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "CHAR" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iC,size_CHAR,fichier_type_imageC);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadIB_image(imageR,nom_image)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(imageIB,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iIB,size_vrai_Int_de_base,fichier_type_imageIB);
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadI_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageI,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iI,size_Int,fichier_type_imageI);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " P O S I T I V E - I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadUB_image(imageR,nom_image)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(imageUB,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iUB,size_vrai_Positive_de_base,fichier_type_imageUB);
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadU_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageU,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iU,size_LPositive,fichier_type_imageU);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E N T A T I V E D E V E R I F I C A T I O N H E U R I S T I Q U E */
/* D E S N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define VERIFICATION_HEURISTIQUE_DES_genere_Float(valider,imageR,F_calcul_extrema,F_verification,seuil_inf,epsi,seuil_sup,editer) \
/* ATTENTION : il a fallu paser de 'epsilon' a 'epsi' le 20031001085104 afin de ne pas */ \
/* perturber le format du 'CAL1(Prer1(...))' qui l'utilise ci-apres... */ \
Bblock \
Test(IL_FAUT(valider)) \
Bblock \
DEFV(genere_Float,INIT(nivo_minimum,FLOT__NIVEAU_UNDEF)); \
DEFV(genere_Float,INIT(nivo_maximum,FLOT__NIVEAU_UNDEF)); \
/* Extrema de l'image courante. */ \
\
Test(IFGE(seuil_inf,seuil_sup)) \
Bblock \
PRINT_ATTENTION("les seuils de validation heuristiques des 'genere_Float's sont incorrects"); \
CAL1(Prer2("ils valent respectivement : %g et %g\n",seuil_inf,seuil_sup)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEXff(Z_Buffer_____valeur_initiale,seuil_inf,seuil_sup)) \
PRINT_ATTENTION("seuils de validation heuristiques des 'genere_Float's incompatibles avec 'Z-Buffer'"); \
CAL1(Prer2("ils valent respectivement : %g et %g\n",seuil_inf,seuil_sup)); \
CAL1(Prer1("et la valeur initiale du 'Z-Buffer' vaut : %g\n",Z_Buffer_____valeur_initiale)); \
Bblock \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALi(F_calcul_extrema(imageR,ADRESSE(nivo_minimum),ADRESSE(nivo_maximum))); \
/* Recherche des extrema de l'image courante. */ \
\
Test(IFOU(IFOU(IFLT(F_calcul_extrema`____niveau_minimum,seuil_inf) \
,IFGT(F_calcul_extrema`____niveau_maximum,seuil_sup) \
) \
,IFET(IZGT(F_calcul_extrema`____niveau_minimum_en_valeur_absolue) \
,IFLT(F_calcul_extrema`____niveau_minimum_en_valeur_absolue,epsi) \
) \
) \
) \
/* Le test sur 'epsi' a ete introduit le 20030930153617 afin de tester des valeurs */ \
/* non nulles et trop petites en valeur absolue... */ \
/* */ \
/* ATTENTION : je note le 20061109090936 que '____niveau_minimum_en_valeur_absolue' est */ \
/* bien present deux fois et que 'niveau_maximum_en_valeur_absolue' est absent ci-dessus... */ \
Bblock \
PRINT_ATTENTION("une image de type 'genere_Float' est peut-etre incompatible avec cette MACHINE (1)"); \
CAL1(Prer2("ses extrema valent respectivement : %g et %g\n",nivo_minimum,nivo_maximum)); \
CAL1(Prer2("alors que les extrema de validation valent respectivement : %g et %g\n" \
,seuil_inf \
,seuil_sup \
) \
); \
CAL1(Prer1("de meme que l'epsilon de validation vaut : %g\n" \
,epsi \
) \
); \
/* Ces editions 'Prer2(...)' ont ete introduites le 20030301091755. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(EST_VRAI(F_verification(imageR,editer))) \
/* Ce dispositif a ete introduit le 20030213093658. */ \
Bblock \
PRINT_ATTENTION("une image de type 'genere_Float' est peut-etre incompatible avec cette MACHINE (2)"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Verification heuristique des 'genere_Float' liee au fait que les representations */ \
/* internes de ces nombres ne sont pas les memes sur 'SYSTEME_APC' et sur les autres */ \
/* SYSTEMEs. Cette procedure a ete introduite le 20030211085553. Il est, par exemple, */ \
/* possible de tester cela avec le fichier '$xie/LACT11.MORL.120615$TF' sur une MACHINE */ \
/* de type 'SYSTEME_APC_Linux' et par exemple sur '$LACT15'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " F L O A T " : */
/* */
/*************************************************************************************************************************************/
#define TRAITEMENT_SPECIFIQUE_DES_FICHIERS_DE_TYPE_Z_Buffer \
Bblock \
Test(PAS_D_ERREUR(CODE_ERREUR)) \
Bblock \
TRAITEMENT_SPECIFIQUE_DES_IMAGES_DE_TYPE_Z_Buffer(imageR); \
/* ATTENTION : le code de 'TRAITEMENT_SPECIFIQUE_DES_IMAGES_DE_TYPE_Z_Buffer' etait */ \
/* implemente explicitement ici avant le 20050418102107 avec une difference importante : la */ \
/* fonction'IFnivo_extrema(...)' etait utilisee alors que dorenavant c'est la fonction */ \
/* 'IFnivo_extrema_avec_exclusion(...)' qui est utilisee a compter donc du 20050418102107. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Traitement specifique des fichiers de type 'Z-Buffer' (chargement, puis validation...). */
BFonctionI
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____un_nom_absent_est_une_erreur,VRAI)));
/* Cet indicateur indique si un nom vide est une erreur (introduit le 20080212093518), */
/* dans le cas contraire 'IloadF_image_____valeur_initiale_si_erreur' est la valeur donnee */
/* a chaque element du fichier. Tout ce qui fut introduit le 20080212093518, le fut */
/* principalement pour 'v $xci/somExt_02.01$K IloadF_image' qui recoit de tres nombreuses */
/* 'imageF' comme Arguments... */
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____tenter_une_conversion_standard_en_cas_d_erreur,FAUX)));
/* En cas d'erreur de lecture en mode 'fichier_type_imageF', cet indicateur permet */
/* d'autoriser une tentative de lecture en mode 'fichier_type_image'. Cette possibilite */
/* fut introduite le 20080916132645... */
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____niveau_minimal_lors_d_une_conversion_standard,FLOT__NOIR)));
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____niveau_maximal_lors_d_une_conversion_standard,FLOT__BLANC)));
/* Si 'IL_FAUT(IloadF_image_____tenter_une_conversion_standard_en_cas_d_erreur)' definissent */
/* les extrema des niveaux a forcer lors du 'Istd_float(...)' qui a alors lieu (introduits */
/* le 20080916132645). */
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur,FAUX)));
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____tenter_un_redimensionnement_en_cas_d_erreur,FAUX)));
DEFV(Common,DEFV(Int,SINT(IloadF_image_____methode_de_redimensionnement_a_utiliser,REECHANTILLONNAGE_PAR_INTERPOLATION_BICUBIQUE)));
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur,FAUX)));
/* En cas d'erreur de lecture en mode 'fichier_type_image', cet indicateur permet de */
/* tenter un redimensionnement suivant une certaine methode (introduit le 20090418182008 */
/* et complete le 20090422092530). */
/* */
/* Le forcage de redimensionnement a ete introduit le 20090502093317 pour prendre en */
/* compte le cas des formats qui sont differents (au niveau 'dimX' et 'dimY') mais qui */
/* correspondent a des 'dimXY' identiques (et donc a des tailles de fichiers identiques). */
/* C'est par exemple le cas des "anti-formats"s : ainsi une image 575x780 ('anti-Pal') */
/* a meme taille (448500) qu'une image 780x575 ('Pal'), les dimensions en 'X' et en 'Y' */
/* etant permutees. Dans un tel cas la taille 'taille_de_imageR' est de 448500 dans les */
/* deux cas. Lors du chargement d'une image au format 'anti-Pal', il n'y a pas d'erreur dans */
/* 'ILOAD_FICHIER_AVEC_CONVERSION(...)' et le test 'IL_Y_A_ERREUR(CODE_ERREUR)' qui suit */
/* est 'FAUX' : la procedure 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' n'est donc pas appelee. */
/* Il faut donc pouvoir dans de tels cas forcer le redimensionnement... */
/* */
/* En ce qui concerne la methode de redimensionnement a utiliser, toutes celles qui sont */
/* disponibles dans 'v $xiii/di_image$DEF types_de_methode_de_redimensionnement' sont */
/* utilisables ici... */
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____tenter_les_conversions_de_nom,TENTER_LES_CONVERSIONS_DANS_IloadF_image)));
/* Cet indicateur indique si les noms qui ressemblent a des valeurs numeriques peuvent etre */
/* utilises comme valeur de tous les points de l'image... */
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____valeur_initiale_si_erreur,FZERO)));
/* Valeur a donner a 'imageR' si l'image 'nom_image' n'existe pas (parametre introduit */
/* le 20021004150125) ou si le nom est absent sans que cela soit une erreur... */
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____initialiser_en_cas_d_erreur_fichier,VRAI)));
/* Introduit le 20101118103438 pour controler l'initialisation de 'imageR' s'il y a un */
/* probleme avec le fichier 'nom_image'... */
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____valider_les_genere_Float,VRAI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____seuil_inferieur_de_validation_des_genere_Float,F_MOINS_LE_PETIT_INFINI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____seuil_epsilon___de_validation_des_genere_Float,F_EPSILON)));
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_____seuil_superieur_de_validation_des_genere_Float,F_PETIT_INFINI)));
DEFV(Common,DEFV(Logical,SINT(IloadF_image_____editer_les_niveaux_invalides,FAUX)));
/* Donnees de validation heuristique (et eventuelle) des 'genere_Float's dans la fonction */
/* 'IloadF_image(...)'. */
/* */
/* Le 20030212091505 la validation est passee de 'FAUX' a 'VRAI', c'est plus prudent... */
/* */
/* Le 20030301093054 fut introduite la possibilite d'editer les anomalies... */
/* */
/* Le 20030930153617 fut introduit le test de petitesse en valeur absolue... */
DEFV(Common,DEFV(FonctionI,IloadF_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageF,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Float" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
BLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS(IloadF_image_____tenter_un_redimensionnement_en_cas_d_erreur);
/* Introduit le 20090422094437... */
ILOAD_FICHIER_AVEC_CONVERSION(nom_image,imageR,size_iF,size_Float,fichier_type_imageF
,IloadF_image_____tenter_les_conversions_de_nom,genere_Float,flot
,IFinitialisation
,IloadF_image_____initialiser_en_cas_d_erreur_fichier
,IloadF_image_____valeur_initiale_si_erreur
,IloadF_image_____un_nom_absent_est_une_erreur
);
/* Tentative de chargement "simple" de l'image a priori... */
/* */
/* On notera que l'on ne place pas ce 'ILOAD_FICHIER_AVEC_CONVERSION(...)' apres le 'ATes' */
/* du 'Test(IL_FAUT(Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur)' (en */
/* supprimant le 'Test(IL_Y_A_ERREUR(CODE_ERREUR))' suivant evidemment...) afin de */
/* simplifier 'TENTATIVE_DE_REDIMENSIONNEMENT(...)' et faire ainsi en sorte qu'il n'y */
/* ait pas de 'IFredimensionnement(...)' s'il n'est pas utile (lorsque 'taille_de_imageR' */
/* est egal a 'TAILLE_D_UN_FICHIER_IMAGE(dimXY,size_Float)'). */
DEBLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS;
/* Introduit le 20090422094437... */
Test(I3OU(IFEQ_chaine(nom_image,C_VIDE)
,IFEQ_chaine(nom_image,NOM_PIPE)
,IFEQ_chaine(nom_image,NOM_PIPE_Local)
)
)
Bblock
/* Lorsque 'nom_image' est {C_VIDE,NOM_PIPE,NOM_PIPE_Local}, il est impossible de refaire */
/* des 'ILOAD_FICHIER_AVEC_CONVERSION(...)'s car, en effet, 'Iload_fichier(...)' a deja */
/* "epuise" le "pipe" d'entree dans le 'ILOAD_FICHIER_AVEC_CONVERSION(...)' qui precede... */
/* Ce test a donc ete introduit le 20090420172620 car il manquait... */
Eblock
ATes
Bblock
Test(IFOU(IL_Y_A_ERREUR(CODE_ERREUR)
,IL_FAUT(IloadF_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur)
)
)
Bblock
#define METHODE_DE_REDIMENSIONNEMENT_A_UTILISER \
IloadF_image_____methode_de_redimensionnement_a_utiliser \
/* Pour raccourcir une des lignes suivantes... */
TENTATIVE_DE_REDIMENSIONNEMENT(IloadF_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur
,IloadF_image_____tenter_un_redimensionnement_en_cas_d_erreur
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
,BLOC(
Bblock
BDEFV(imageF,imageR_mal_dimensionnee);
ILOAD_FICHIER_AVEC_CONVERSION(nom_image
,imageR_mal_dimensionnee
,size_iF
,size_Float
,fichier_type_imageF
,IloadF_image_____tenter_les_conversions_de_nom
,genere_Float
,flot
,IFinitialisation
,IloadF_image_____initialiser_en_cas_d_erreur_fichier
,IloadF_image_____valeur_initiale_si_erreur
,IloadF_image_____un_nom_absent_est_une_erreur
);
/* Tentative de rechargement de l'image 'nom_image', mais en ayant mis en place ses */
/* possibles dimensions {{Xmin,Xmax},{Ymin,Ymax}}. */
CALS(IFredimensionnement(imageR
,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax
,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax
,imageR_mal_dimensionnee
,Xmin,Xmax,Ymin,Ymax
,METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
)
);
/* Redimensionnement... */
EDEFV(imageF,imageR_mal_dimensionnee);
Eblock
)
,size_Float
,IloadF_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur
);
#undef METHODE_DE_REDIMENSIONNEMENT_A_UTILISER
Test(IL_Y_A_ERREUR(CODE_ERREUR))
Bblock
Test(IL_FAUT(IloadF_image_____tenter_une_conversion_standard_en_cas_d_erreur))
/* Cette possibilite fut introduite le 20080916132645... */
Bblock
BDEFV(image,imageR_standard);
/* Image "standard" que l'on va tenter de lire, puis convertir... */
EGAL(CODE_ERREUR,OK);
/* A priori... */
MESSAGES_DES_FICHIERS(Prer2("Une lecture 'standard=%s' et une conversion 'standard=%s' vont etre tentees.\n"
,C_VRAI____
,C_FAUX____
)
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
);
ILOAD_FICHIER_AVEC_CONVERSION(nom_image
,imageR_standard
,size_i
,size_p
,fichier_type_image
,IloadF_image_____tenter_les_conversions_de_nom
,genere_p
,genp
,Iinitialisation
,IloadF_image_____initialiser_en_cas_d_erreur_fichier
,GENP(IloadF_image_____valeur_initiale_si_erreur)
,IloadF_image_____un_nom_absent_est_une_erreur
);
/* Tentative de lecture de 'imageR' en mode "standard"... */
CALS(Istd_float(imageR
,IloadF_image_____niveau_minimal_lors_d_une_conversion_standard
,IloadF_image_____niveau_maximal_lors_d_une_conversion_standard
,imageR_standard
)
);
/* Et conversion qu'il n'y ait pas eu d'erreur ou qu'il y en ait eu une. En effet, dans ce */
/* dernier cas 'ILOAD_FICHIER_AVEC_CONVERSION(...)' procede a une initialisation... */
EDEFV(image,imageR_standard);
/* Image "standard" que l'on va tenter de lire, puis convertir... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
TRAITEMENT_SPECIFIQUE_DES_FICHIERS_DE_TYPE_Z_Buffer;
VERIFICATION_HEURISTIQUE_DES_genere_Float(IloadF_image_____valider_les_genere_Float
,imageR
,__IFnivo_extrema
,IFau_moins_un_niveau_est_incorrect
,IloadF_image_____seuil_inferieur_de_validation_des_genere_Float
,IloadF_image_____seuil_epsilon___de_validation_des_genere_Float
,IloadF_image_____seuil_superieur_de_validation_des_genere_Float
,IloadF_image_____editer_les_niveaux_invalides
);
/* L'utilisation du nom '__IFnivo_extrema' (et non pas de 'IFnivo_extrema') est due a */
/* l'utilisation dans la procedure 'VERIFICATION_HEURISTIQUE_DES_genere_Float(...)' de */
/* l'operateur de concatenation "`"... */
RETU_ERROR;
Eblock
EFonctionI
#undef TENTATIVE_DE_REDIMENSIONNEMENT
#undef SELECTION_DU_FORMAT_DE_REDIMENSIONNEMENT
#undef DEBLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS
#undef BLOCAGE_EVENTUEL_DES_MESSAGES_D_ERREUR_DES_FICHIERS
#undef ILOAD_FICHIER_AVEC_CONVERSION
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " F L O A T " S I P R E S E N T : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadF_image_si_present(imageR,nom_image,nom_image_absent,valeur_par_defaut)))
/* Fonction introduite le 20041230213528... */
DEFV(Argument,DEFV(imageF,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
DEFV(Argument,DEFV(CHAR,DTb0(nom_image_absent)));
/* Nom de l'image "standard" a lire et nom au cas ou il n'y a pas de nom... */
DEFV(Argument,DEFV(genere_Float,valeur_par_defaut));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_IMAGE_SI_PRESENT(imageR,nom_image,nom_image_absent,valeur_par_defaut,IloadF_image,IFinitialisation);
RETU_ERROR;
Eblock
EFonctionI
#undef ILOAD_IMAGE_SI_PRESENT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadD_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageD,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Double" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iD,size_Double,fichier_type_imageD);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(IloadJ_image_____valider_les_genere_Float,VRAI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_____seuil_inferieur_de_validation_des_genere_Float,F_MOINS_LE_PETIT_INFINI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_____seuil_epsilon___de_validation_des_genere_Float,F_EPSILON)));
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_____seuil_superieur_de_validation_des_genere_Float,F_PETIT_INFINI)));
DEFV(Common,DEFV(Logical,SINT(IloadJ_image_____editer_les_niveaux_invalides,FAUX)));
/* Donnees de validation heuristique (et eventuelle) des 'genere_Float's dans la fonction */
/* 'IloadJ_image(...)'. */
/* */
/* Le 20030212091505 la validation est passee de 'FAUX' a 'VRAI', c'est plus prudent... */
/* */
/* Le 20030301093054 fut introduite la possibilite d'editer les anomalies... */
/* */
/* Le 20030930153617 fut introduit le test de petitesse en valeur absolue... */
DEFV(Common,DEFV(FonctionI,IloadJ_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "complexe" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iJ,size_complexe,fichier_type_imageJ);
VERIFICATION_HEURISTIQUE_DES_genere_Float(IloadJ_image_____valider_les_genere_Float
,imageR
,__IJnivo_extrema
,IJau_moins_un_niveau_est_incorrect
,IloadJ_image_____seuil_inferieur_de_validation_des_genere_Float
,IloadJ_image_____seuil_epsilon___de_validation_des_genere_Float
,IloadJ_image_____seuil_superieur_de_validation_des_genere_Float
,IloadJ_image_____editer_les_niveaux_invalides
);
/* L'utilisation du nom '__IJnivo_extrema' (et non pas de 'IJnivo_extrema') est due a */
/* l'utilisation dans la procedure 'VERIFICATION_HEURISTIQUE_DES_genere_Float(...)' de */
/* l'operateur de concatenation "`"... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadHJ_image(imageR,nom_image)))
DEFV(Argument,DEFV(imageHJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-complexe" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iHJ,size_hyper_complexe,fichier_type_imageHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " H Y P E R - H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadHHJ_image(imageR,nom_image)))
/* Fonction introduite le 20150227110432... */
DEFV(Argument,DEFV(imageHHJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-hyper-complexe" a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER(nom_image,imageR,size_iHHJ,size_hyper_hyper_complexe,fichier_type_imageHHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " S T A N D A R D " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Iload_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(image,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_i,size_p,fichier_type_image);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " C H A R " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadC_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageC,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "CHAR" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iC,size_CHAR,fichier_type_imageC);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " I N T " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadI_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageI,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iI,size_Int,fichier_type_imageI);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " P O S I T I V E - I N T " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadU_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageU,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iU,size_LPositive,fichier_type_imageU);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " F L O A T " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(IloadF_image_and_delete_____valider_les_genere_Float,VRAI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float
,F_MOINS_LE_PETIT_INFINI
)
)
);
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float
,F_EPSILON
)
)
);
DEFV(Common,DEFV(genere_Float,SINT(IloadF_image_and_delete_____seuil_superieur_de_validation_des_genere_Float
,F_PETIT_INFINI
)
)
);
DEFV(Common,DEFV(Logical,SINT(IloadF_image_and_delete_____editer_les_niveaux_invalides,FAUX)));
/* Donnees de validation heuristique (et eventuelle) des 'genere_Float's dans la fonction */
/* 'IloadF_image_and_delete(...)'. */
/* */
/* Le 20030212091505 la validation est passee de 'FAUX' a 'VRAI', c'est plus prudent... */
/* */
/* Le 20030301093054 fut introduite la possibilite d'editer les anomalies... */
/* */
/* Le 20030930153617 fut introduit le test de petitesse en valeur absolue... */
DEFV(Common,DEFV(FonctionI,IloadF_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageF,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Float" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iF,size_Float,fichier_type_imageF);
TRAITEMENT_SPECIFIQUE_DES_FICHIERS_DE_TYPE_Z_Buffer;
VERIFICATION_HEURISTIQUE_DES_genere_Float(IloadF_image_and_delete_____valider_les_genere_Float
,imageR
,__IFnivo_extrema
,IFau_moins_un_niveau_est_incorrect
,IloadF_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float
,IloadF_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float
,IloadF_image_and_delete_____seuil_superieur_de_validation_des_genere_Float
,IloadF_image_and_delete_____editer_les_niveaux_invalides
);
/* L'utilisation du nom '__IFnivo_extrema' (et non pas de 'IFnivo_extrema') est due a */
/* l'utilisation dans la procedure 'VERIFICATION_HEURISTIQUE_DES_genere_Float(...)' de */
/* l'operateur de concatenation "`"... */
RETU_ERROR;
Eblock
EFonctionI
#undef TRAITEMENT_SPECIFIQUE_DES_FICHIERS_DE_TYPE_Z_Buffer
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " D O U B L E " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadD_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageD,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Double" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iD,size_Double,fichier_type_imageD);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " C O M P L E X E " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(IloadJ_image_and_delete_____valider_les_genere_Float,VRAI)));
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float
,F_MOINS_LE_PETIT_INFINI
)
)
);
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float
,F_EPSILON
)
)
);
DEFV(Common,DEFV(genere_Float,SINT(IloadJ_image_and_delete_____seuil_superieur_de_validation_des_genere_Float
,F_PETIT_INFINI
)
)
);
DEFV(Common,DEFV(Logical,SINT(IloadJ_image_and_delete_____editer_les_niveaux_invalides,FAUX)));
/* Donnees de validation heuristique (et eventuelle) des 'genere_Float's dans la fonction */
/* 'IloadJ_image_and_delete(...)'. */
/* */
/* Le 20030212091505 la validation est passee de 'FAUX' a 'VRAI', c'est plus prudent... */
/* */
/* Le 20030301093054 fut introduite la possibilite d'editer les anomalies... */
/* */
/* Le 20030930153617 fut introduit le test de petitesse en valeur absolue... */
DEFV(Common,DEFV(FonctionI,IloadJ_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "complexe" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iJ,size_complexe,fichier_type_imageJ);
VERIFICATION_HEURISTIQUE_DES_genere_Float(IloadJ_image_and_delete_____valider_les_genere_Float
,imageR
,__IJnivo_extrema
,IJau_moins_un_niveau_est_incorrect
,IloadJ_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float
,IloadJ_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float
,IloadJ_image_and_delete_____seuil_superieur_de_validation_des_genere_Float
,IloadJ_image_and_delete_____editer_les_niveaux_invalides
);
/* L'utilisation du nom '__IJnivo_extrema' (et non pas de 'IJnivo_extrema') est due a */
/* l'utilisation dans la procedure 'VERIFICATION_HEURISTIQUE_DES_genere_Float(...)' de */
/* l'operateur de concatenation "`"... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " H Y P E R - C O M P L E X E " P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadHJ_image_and_delete(imageR,nom_image)))
DEFV(Argument,DEFV(imageHJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-complexe" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iHJ,size_hyper_complexe,fichier_type_imageHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - I M A G E " H Y P E R - H Y P E R - C O M P L E X E " */
/* P U I S D E S T R U C T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IloadHHJ_image_and_delete(imageR,nom_image)))
/* Fonction introduite le 20150227110432... */
DEFV(Argument,DEFV(imageHHJ,imageR));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-hyper-complexe" a lire puis a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ILOAD_FICHIER_AND_DELETE(nom_image,imageR,size_iHHJ,size_hyper_hyper_complexe,fichier_type_imageHHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " S T A N D A R D " */
/* A V E C D ' E V E N T U E L S P O S T - T R A I T E M E N T S : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define COMPTER_LES_OPTIONS_DE_Istore_image(option) \
COND(IL_FAUT(option),UN,ZERO)
DEFV(Common,DEFV(Logical,SINT(Istore_image_____permuter_les_bits_de_l_image,FAUX)));
DEFV(Common,DEFV(Positive,SINT(Istore_image_____taille_des_paquets_de_bits,TAILLE_PAR_DEFAUT_DES_PAQUETS_DE_PERMUTATION_DES_BITS)));
DEFV(Common,DEFV(Int,SINT(Istore_image_____translation_des_index_de_bits,TRANSLATION_PAR_DEFAUT_DES_INDEX_DE_BITS)));
/* Parametrage de 'Istore_image(...)' introduit le 20161128145425... */
DEFV(Common,DEFV(Logical,SINT(Istore_image_____renormaliser_l_image,FAUX)));
DEFV(Common,DEFV(genere_p,SINT(Istore_image_____niveau_minimal_de_renormalisation,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(Istore_image_____niveau_maximal_de_renormalisation,BLANC)));
/* Parametrage de 'Istore_image(...)' introduit le 20130707181804... */
DEFV(Common,DEFV(Logical,SINT(Istore_image_____complementer_l_image,FAUX)));
/* Parametrage de 'Istore_image(...)' introduit le 20161129100713... */
DEFV(Common,DEFV(FonctionI,Istore_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a ecrire. */
DEFV(Argument,DEFV(image,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(IFGT(ADD3(COMPTER_LES_OPTIONS_DE_Istore_image(Istore_image_____permuter_les_bits_de_l_image)
,COMPTER_LES_OPTIONS_DE_Istore_image(Istore_image_____renormaliser_l_image)
,COMPTER_LES_OPTIONS_DE_Istore_image(Istore_image_____complementer_l_image)
)
,UN
)
)
/* Test introduit le 20161129100713... */
Bblock
PRINT_ATTENTION("plusieurs options sont demandees, mais seule la premiere sera utilisee, les suivantes etant ignorees");
Eblock
ATes
Bblock
Eblock
ETes
TestU
/* En consequence de 'TestU' (introduit le 20161128144206), les options : */
/* */
/* Istore_image_____complementer_l_image */
/* Istore_image_____permuter_les_bits_de_l_image */
/* Istore_image_____renormaliser_l_image */
/* */
/* s'excluent mutuellement... */
Bblock
UCAse(IL_FAUT(Istore_image_____permuter_les_bits_de_l_image))
/* Permutation des bits de l'image (possibilite introduite le 20130707181804...). */
/* */
/* Cela permet de "mimer" la gestion d'images de type "bits" (et non plus d'"octets"). En */
/* effet, on va ci-dessous archiver une image, mais dont les bits seront "classes" */
/* plan par plan. Si '..._____translation_des_index_de_bits' est nul, alors on trouvera en */
/* tete du fichier les bits de poids le plus fort (2^7), puis 2^6,..., jusqu'a 2^0. En */
/* donnant a '..._____translation_des_index_de_bits' une valeur differente, on pourra */
/* ainsi selectionner le plan de bit qui se trouvera en tete... */
/* */
/* La mise sous la forme 'UCAse(...)' a ete faite le 20161128144206... */
Bblock
BDEFV(image,imageA_permutee);
BSaveModifyVariable(Int
,Ipermutation_directe_de_regroupement_des_bits_de_meme_poids_____taille_des_paquets_de_bits
,Istore_image_____taille_des_paquets_de_bits
);
BSaveModifyVariable(Int
,Ipermutation_directe_de_regroupement_des_bits_de_meme_poids_____translation_des_index_de_bits
,Istore_image_____translation_des_index_de_bits
);
/* Parametrage de la permutation directe... */
CALi(Ipermutation_directe_de_regroupement_des_bits_de_meme_poids(imageA_permutee,imageA));
/* Permutation directe... */
ISTORE_FICHIER(imageA_permutee,nom_image,size_i,size_p,fichier_type_image);
/* Archivage du fichier permute... */
ESaveModifyVariable(Int
,Ipermutation_directe_de_regroupement_des_bits_de_meme_poids_____translation_des_index_de_bits
);
ESaveModifyVariable(Int
,Ipermutation_directe_de_regroupement_des_bits_de_meme_poids_____taille_des_paquets_de_bits
);
EDEFV(image,imageA_permutee);
Eblock
EUCAs
UCAse(IL_FAUT(Istore_image_____renormaliser_l_image))
/* Renormalisation de l'image (possibilite introduite le 20161128145425...). */
Bblock
BDEFV(imageF,image_flottante_de_renormalisation);
BDEFV(image,image_renormalisee);
BSaveModifyVariable(genere_p
,Ifloat_std_____niveau_NOIR
,Istore_image_____niveau_minimal_de_renormalisation
);
BSaveModifyVariable(genere_p
,Ifloat_std_____niveau_BLANC
,Istore_image_____niveau_maximal_de_renormalisation
);
CALS(Istd_float(image_flottante_de_renormalisation
,FLOT__NOIR
,FLOT__BLANC
,imageA
)
);
CALS(Ifloat_std_avec_renormalisation(image_renormalisee,image_flottante_de_renormalisation));
/* Lorsqu'il faut renormaliser, on passe par une representation flottante intermediaire... */
ESaveModifyVariable(genere_p
,Ifloat_std_____niveau_BLANC
);
ESaveModifyVariable(genere_p
,Ifloat_std_____niveau_NOIR
);
ISTORE_FICHIER(image_renormalisee,nom_image,size_i,size_p,fichier_type_image);
/* Archivage du fichier renormalise... */
EDEFV(image,image_renormalisee);
EDEFV(imageF,image_flottante_de_renormalisation);
Eblock
EUCAs
UCAse(IL_FAUT(Istore_image_____complementer_l_image))
/* Complementation de l'image (possibilite introduite le 20161129100713...). */
Bblock
BDEFV(image,image_complementee);
CALS(Icomplementation(image_complementee,imageA));
ISTORE_FICHIER(image_complementee,nom_image,size_i,size_p,fichier_type_image);
/* Archivage du fichier renormalise... */
EDEFV(image,image_complementee);
Eblock
EUCAs
UDEfo
Bblock
ISTORE_FICHIER(imageA,nom_image,size_i,size_p,fichier_type_image);
/* Cas le plus frequent ou 'imageA' n'est l'objet d'aucun post-traitement... */
Eblock
EUDEf
Eblock
ETestU
RETU_ERROR;
Eblock
#undef COMPTER_LES_OPTIONS_DE_Istore_image
EFonctionI
#undef VERIFICATION_HEURISTIQUE_DES_genere_Float
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N E I M A G E E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_de_l_image,imageA,type_de_la_composante,espace_de_couleurs,archiver) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_l_image \
,type_de_la_composante \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Istore_image(nom_composante_image \
,imageA \
) \
); \
) \
,archiver \
); \
Eblock \
/* Tentative de d'archivage de la composante courante... */
DEFV(Common,DEFV(FonctionI,Istore_image_en_couleurs(nom_image,imageA_COMP1,imageA_COMP2,imageA_COMP3,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a archiver. */
DEFV(Argument,DEFV(image,imageA_COMP1));
DEFV(Argument,DEFV(image,imageA_COMP2));
DEFV(Argument,DEFV(image,imageA_COMP3));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP1
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_image_en_couleurs
);
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP2
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_image_en_couleurs
);
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP3
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_image_en_couleurs
);
RETU_ERROR;
Eblock
#undef ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " S T A N D A R D " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Iupdate_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "standard" a mettre a jour. */
DEFV(Argument,DEFV(image,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(Istore_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N E I M A G E E N C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define UPDATE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_de_l_image,imageA,type_de_la_composante,espace_de_couleurs,updater) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_l_image \
,type_de_la_composante \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Iupdate_image(nom_composante_image \
,imageA \
) \
); \
) \
,updater \
); \
Eblock \
/* Tentative d'update de la composante courante... */
DEFV(Common,DEFV(FonctionI,Iupdate_image_en_couleurs(nom_image,imageA_COMP1,imageA_COMP2,imageA_COMP3,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image a mettre a jour. */
DEFV(Argument,DEFV(image,imageA_COMP1));
DEFV(Argument,DEFV(image,imageA_COMP2));
DEFV(Argument,DEFV(image,imageA_COMP3));
/* Adresse de l'image en memoire, */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
UPDATE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP1
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_image_en_couleurs
);
UPDATE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP2
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_image_en_couleurs
);
UPDATE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS(nom_image
,imageA_COMP3
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_image_en_couleurs
);
RETU_ERROR;
Eblock
#undef UPDATE_D_UNE_COMPOSANTE_D_UNE_IMAGE_EN_COULEURS
EFonctionI
#undef nom_composante_image
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " C H A R " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreC_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "CHAR" a ecrire. */
DEFV(Argument,DEFV(imageC,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iC,size_CHAR,fichier_type_imageC);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " C H A R " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateC_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "CHAR" a mettre a jour. */
DEFV(Argument,DEFV(imageC,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreC_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreIB_image(nom_image,imageA)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a ecrire. */
DEFV(Argument,DEFV(imageIB,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iIB,size_vrai_Int_de_base,fichier_type_imageIB);
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreI_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a ecrire. */
DEFV(Argument,DEFV(imageI,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iI,size_Int,fichier_type_imageI);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateIB_image(nom_image,imageA)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a mettre a jour. */
DEFV(Argument,DEFV(imageIB,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreIB_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateI_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Int" a mettre a jour. */
DEFV(Argument,DEFV(imageI,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreI_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " P O S I T I V E - I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreUB_image(nom_image,imageA)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a ecrire. */
DEFV(Argument,DEFV(imageUB,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iUB,size_vrai_Positive_de_base,fichier_type_imageUB);
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreU_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a ecrire. */
DEFV(Argument,DEFV(imageU,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iU,size_LPositive,fichier_type_imageU);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " P O S I T I V E - I N T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateUB_image(nom_image,imageA)))
/* Fonction introduite le 20100326190221... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a mettre a jour. */
DEFV(Argument,DEFV(imageUB,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreUB_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateU_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Positive" a mettre a jour. */
DEFV(Argument,DEFV(imageU,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreU_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " F L O A T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreF_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Float" a ecrire. */
DEFV(Argument,DEFV(imageF,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iF,size_Float,fichier_type_imageF);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " F L O A T " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateF_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Float" a mettre a jour. */
DEFV(Argument,DEFV(imageF,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreF_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreD_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Double" a ecrire. */
DEFV(Argument,DEFV(imageD,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iD,size_Double,fichier_type_imageD);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " D O U B L E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateD_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "Double" a mettre a jour. */
DEFV(Argument,DEFV(imageD,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreD_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreJ_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "complexe" a ecrire. */
DEFV(Argument,DEFV(imageJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iJ,size_complexe,fichier_type_imageJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateJ_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "complexe" a mettre a jour. */
DEFV(Argument,DEFV(imageJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreJ_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreHJ_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-complexe" a ecrire. */
DEFV(Argument,DEFV(imageHJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iHJ,size_hyper_complexe,fichier_type_imageHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateHJ_image(nom_image,imageA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-complexe" a mettre a jour. */
DEFV(Argument,DEFV(imageHJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreHJ_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - I M A G E " H Y P E R - H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IstoreHHJ_image(nom_image,imageA)))
/* Fonction introduite le 20150227110432... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-hyper-complexe" a ecrire. */
DEFV(Argument,DEFV(imageHHJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ISTORE_FICHIER(imageA,nom_image,size_iHHJ,size_hyper_hyper_complexe,fichier_type_imageHHJ);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - I M A G E " H Y P E R - H Y P E R - C O M P L E X E " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IupdateHHJ_image(nom_image,imageA)))
/* Fonction introduite le 20150227110432... */
DEFV(Argument,DEFV(CHAR,DTb0(nom_image)));
/* Nom de l'image "hyper-hyper-complexe" a mettre a jour. */
DEFV(Argument,DEFV(imageHHJ,imageA));
/* Adresse de l'image en memoire, */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_image(nom_image));
CODE_ERROR(IstoreHHJ_image(nom_image,imageA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D E L ' E X I S T E N C E D ' U N E L I S T E D E S U B S T I T U T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Itest_liste_de_substitution(nom_liste_de_substitution)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_liste_de_substitution)));
/* Nom de la liste_de_substitution a tester. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE;
CODE_ERROR(Itest_fichier(nom_liste_de_substitution));
ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE;
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A N I P U L A T I O N D ' U N E P A L E T T E D E C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
#define nom_composante_palette \
nom_composante_objet \
/* Pour ameliorer la lisibilite... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E S T R U C T I O N D ' U N E L I S T E D E S U B S T I T U T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Idelete_liste_de_substitution(nom_liste_de_substitution)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_liste_de_substitution)));
/* Nom de la liste_de_substitution a detruire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE;
CODE_ERROR(Idelete_fichier(nom_liste_de_substitution));
ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE;
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N H I B I T I O N E V E N T U E L L E D E L A M A N I P U L A T I O N */
/* D E S C O M P O S A N T E S D ' U N E P A L E T T E D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP1_d_une_palette_de_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP2_d_une_palette_de_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
DEFV(Common,DEFV(Logical,ZINT(files_____manipuler_la_composante_COMP3_d_une_palette_de_couleurs
,MANIPULER_UNE_COMPOSANTE_OBJET_COULEURS
)
)
);
/* Afin d'inhiber, eventuellement, 'MANIPULATION_COMPOSANTE_OBJET_COULEURS(...)' pour un */
/* fichier de type "palette". */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E S T R U C T I O N D ' U N E P A L E T T E D E C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_de_la_palette,type_compos,espace_de_couleurs,detruire) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_la_palette \
,type_compos \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Idelete_liste_de_substitution(nom_composante_palette \
) \
); \
) \
,detruire \
); \
Eblock \
/* Tentative de destruction de la composante courante... */
DEFV(Common,DEFV(FonctionI,Idelete_palette_de_couleurs(nom_palette,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_palette)));
/* Nom de la palette a detruire. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_palette_de_couleurs
);
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_palette_de_couleurs
);
DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_palette_de_couleurs
);
RETU_ERROR;
Eblock
#undef DESTRUCTION_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R - L I S T E D E S U B S T I T U T I O N : */
/* */
/*************************************************************************************************************************************/
#define LOAD_FICHIER_DE_SUBSTITUTION(fichier_de_substitution) \
CAse(fichier_de_substitution) \
Bblock \
MISE_A_L_ETAT_INITIAL_LISTE_DE_SUBSTITUTION; \
/* Lorsque la liste de substitution n'a pas ete encore initialisee, */ \
/* on le fait avant la lecture du fichier... */ \
ILOAD_FICHIER(nom_liste_de_substitution \
,ITb0(listes_de_substitution \
,INDX(fichier_de_substitution \
,L_SUBSTITUTION_FIRST \
) \
) \
,MUL2(COULEURS,size_p) \
,size_p \
,fichier_type_liste_de_substitution \
); \
CLEAR_LISTE_INVERSE_DE_SUBSTITUTION(fichier_de_substitution) \
/* Initialisation preliminaire a 'NIVEAU_UNDEF' des listes "inverses". */ \
BoIn(index,NOIR,BLANC,PAS_COULEURS) \
Bblock \
CALCUL_LISTE_INVERSE_DE_SUBSTITUTION(fichier_de_substitution,index); \
Eblock \
EBoI \
/* Puis calcul de la liste "inverse". */ \
Eblock \
ECAs
BFonctionI
DEFV(Common,DEFV(FonctionI,Iload_liste_de_substitution(num_liste_de_substitutionR,nom_liste_de_substitution)))
DEFV(Argument,DEFV(Int,num_liste_de_substitutionR));
/* Identification de la liste de substitution a lire. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_liste_de_substitution)));
/* Nom de la liste_de_substitution a lire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE;
CHoi(num_liste_de_substitutionR)
Bblock
LOAD_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_VARIABLE)
LOAD_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_ROUGE)
LOAD_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_VERTE)
LOAD_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_BLEUE)
DEfo
Bblock
PRINT_ERREUR("la liste de substitution demandee est inaccessible");
CODE_ERROR(ERREUR14);
Eblock
EDEf
Eblock
ECHo
ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE;
RETU_ERROR;
Eblock
EFonctionI
#undef LOAD_FICHIER_DE_SUBSTITUTION
#undef ILOAD_FICHIER
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N E P A L E T T E D E C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define NOM_DE_LA_PALETTE_PAR_DEFAUT \
"NomPaletteParDefaut" \
/* Nom de la palette par defaut (introduit le 20150518144431). */
#define ACCES_A_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_de_la_palette,type_compos,espace_de_couleurs,acceder) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_la_palette \
,type_compos \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Iload_liste_de_substitution(L_SUBSTITUTION`type_compos \
,nom_composante_palette \
) \
); \
) \
,acceder \
); \
Eblock \
/* Tentative d'acces a la composante courante... */
DEFV(Common,DEFV(Logical,SINT(Iload_palette_de_couleurs_____forcer_un_niveau,FAUX)));
DEFV(Common,DEFV(genere_p,SINT(Iload_palette_de_couleurs_____niveau_a_forcer,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(Iload_palette_de_couleurs_____composante_ROUGE_du_niveau_a_forcer,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(Iload_palette_de_couleurs_____composante_VERTE_du_niveau_a_forcer,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(Iload_palette_de_couleurs_____composante_BLEUE_du_niveau_a_forcer,NOIR)));
/* Afin de permettre en particulier de forcer au NOIR le premier niveau de chaque */
/* palette dans 'v $xci/display$X Iload_palette_de_couleurs_____forcer_un_niveau' */
/* (introduit le 20231128130908). */
DEFV(Common,DEFV(FonctionI,Iload_palette_de_couleurs(nom_palette,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_palette)));
/* Nom de la palette a charger. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIT(POINTERc(nom_palette_effective),CHAINE_UNDEF));
DEFV(CHAR,INIT(POINTERc(nom_palette_par_defaut),Gvar(NOM_DE_LA_PALETTE_PAR_DEFAUT)));
/* Nom de la palette effectivement utilisee et nom de l'eventuelle palette par defaut */
/* au cas ou... */
INIT_ERROR;
/*..............................................................................................................................*/
Test(IFET(IFEQ_chaine(nom_palette,NOM_PIPE)
,IFNE_chaine(nom_palette_par_defaut,VALEUR_D_UNE_VARIABLE_UNDEF)
)
)
Bblock
EGAL(nom_palette_effective,nom_palette_par_defaut);
/* Possibilite introduite le 20150518144431. Dans ce cas, il existe une palette par */
/* defaut dont le nom est donne par la variable d'environnement '$NomPaletteParDefaut'... */
Eblock
ATes
Bblock
EGAp(nom_palette_effective,chain_Acopie(nom_palette));
Eblock
ETes
ACCES_A_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette_effective
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_palette_de_couleurs
);
ACCES_A_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette_effective
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_palette_de_couleurs
);
ACCES_A_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette_effective
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_palette_de_couleurs
);
Test(IL_FAUT(Iload_palette_de_couleurs_____forcer_un_niveau))
Bblock
EGAL(ACCES_listes_de_substitution(L_SUBSTITUTION_ROUGE,Iload_palette_de_couleurs_____niveau_a_forcer)
,Iload_palette_de_couleurs_____composante_ROUGE_du_niveau_a_forcer
);
EGAL(ACCES_listes_de_substitution(L_SUBSTITUTION_VERTE,Iload_palette_de_couleurs_____niveau_a_forcer)
,Iload_palette_de_couleurs_____composante_VERTE_du_niveau_a_forcer
);
EGAL(ACCES_listes_de_substitution(L_SUBSTITUTION_BLEUE,Iload_palette_de_couleurs_____niveau_a_forcer)
,Iload_palette_de_couleurs_____composante_BLEUE_du_niveau_a_forcer
);
/* Afin de permettre en particulier de forcer au NOIR le premier niveau de chaque */
/* palette dans 'v $xci/display$X Iload_palette_de_couleurs_____forcer_un_niveau' */
/* (introduit le 20231128130908). */
Eblock
ATes
Bblock
Eblock
ETes
RETU_ERROR;
Eblock
#undef NOM_DE_LA_PALETTE_PAR_DEFAUT
#undef ACCES_A_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R - L I S T E D E S U B S T I T U T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define STORE_FICHIER_DE_SUBSTITUTION(fichier_de_substitution) \
CAse(fichier_de_substitution) \
Bblock \
ISTORE_FICHIER(ITb0(listes_de_substitution \
,INDX(num_liste_de_substitutionA \
,L_SUBSTITUTION_NEUTRE \
) \
) \
,nom_liste_de_substitution \
,MUL2(COULEURS,size_p) \
,size_p \
,fichier_type_liste_de_substitution \
); \
Eblock \
ECAs
DEFV(Common,DEFV(FonctionI,Istore_liste_de_substitution(nom_liste_de_substitution,num_liste_de_substitutionA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_liste_de_substitution)));
/* Nom de la liste_de_substitution a ecrire. */
DEFV(Argument,DEFV(Int,num_liste_de_substitutionA));
/* Identification de la liste de substitution a ecrire. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE;
CHoi(num_liste_de_substitutionA)
Bblock
STORE_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_VARIABLE)
STORE_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_ROUGE)
STORE_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_VERTE)
STORE_FICHIER_DE_SUBSTITUTION(L_SUBSTITUTION_BLEUE)
DEfo
Bblock
PRINT_ERREUR("la liste de substitution demandee est inaccessible");
CODE_ERROR(ERREUR14);
Eblock
EDEf
Eblock
ECHo
ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE;
RETU_ERROR;
Eblock
#undef STORE_FICHIER_DE_SUBSTITUTION
EFonctionI
#undef ENTREE_DANS_UNE_SECTION_OU_NOM_FICHIER_DESIGNE_UNE_PALETTE
#undef ENTREE_DANS_UNE_SECTION_OU_ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N E P A L E T T E D E C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_de_la_palette,type_compos,espace_de_couleurs,archiver) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_la_palette \
,type_compos \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Istore_liste_de_substitution(nom_composante_palette \
,L_SUBSTITUTION`type_compos \
) \
); \
) \
,archiver \
); \
Eblock \
/* Tentative d'archivage de la composante courante... */
DEFV(Common,DEFV(FonctionI,Istore_palette_de_couleurs(nom_palette,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_palette)));
/* Nom de la palette a archiver. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_palette_de_couleurs
);
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_palette_de_couleurs
);
ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_palette_de_couleurs
);
RETU_ERROR;
Eblock
#undef ARCHIVAGE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N F I C H I E R - L I S T E D E S U B S T I T U T I O N : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,Iupdate_liste_de_substitution(nom_liste_de_substitution,num_liste_de_substitutionA)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_liste_de_substitution)));
/* Nom de la liste_de_substitution a mettre a jour. */
DEFV(Argument,DEFV(Int,num_liste_de_substitutionA));
/* Identification de la liste de substitution a mettre a jour. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
CALS(Idelete_liste_de_substitution(nom_liste_de_substitution));
CODE_ERROR(Istore_liste_de_substitution(nom_liste_de_substitution,num_liste_de_substitutionA));
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* U P D A T E D ' U N E P A L E T T E D E C O U L E U R S ( ' R V B ' O U ' H L S ' ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
#define UPDATE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_de_la_palette,type_compos,espace_de_couleurs,updater) \
Bblock \
MANIPULATION_COMPOSANTE_OBJET_COULEURS(nom_de_la_palette \
,type_compos \
,espace_de_couleurs \
,BLOC(CODE_ERROR(Iupdate_liste_de_substitution(nom_composante_palette \
,L_SUBSTITUTION`type_compos \
) \
); \
) \
,updater \
); \
Eblock \
/* Tentative de mise a jour de la composante courante... */
DEFV(Common,DEFV(FonctionI,Iupdate_palette_de_couleurs(nom_palette,nom_de_l_espace_de_couleurs)))
DEFV(Argument,DEFV(CHAR,DTb0(nom_palette)));
/* Nom de la palette a mettre a jour. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_l_espace_de_couleurs)));
/* Nom de l'espace de couleurs a choisir parmi : */
/* */
/* ESPACE_DE_COULEURS_RVB */
/* ESPACE_DE_COULEURS_HLS */
/* */
/* voir a ce propos 'v $xiii/quad_image$DEF'. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
UPDATE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP1
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP1_d_une_palette_de_couleurs
);
UPDATE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP2
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP2_d_une_palette_de_couleurs
);
UPDATE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS(nom_palette
,COMP3
,nom_de_l_espace_de_couleurs
,files_____manipuler_la_composante_COMP3_d_une_palette_de_couleurs
);
RETU_ERROR;
Eblock
#undef UPDATE_D_UNE_COMPOSANTE_D_UNE_PALETTES_DE_COULEURS
EFonctionI
#undef nom_composante_palette
#undef MANIPULATION_COMPOSANTE_OBJET_COULEURS
#undef ISTORE_FICHIER
#undef ILOAD_FICHIER_AND_DELETE
#undef EQUIVALENCE_FICHIER
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* N O T I O N D E " C O M M A N D E - F I C H I E R " : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : voir les commentaires suivants et relatifs a 'Iload_fichier(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R D A N S L E P I P E S I L E N O M E S T V I D E */
/* S I N O N */
/* D A N S L E D I R E C T O R Y " i m a g e s " */
/* P U I S */
/* D A N S L E D I R E C T O R Y C O U R A N T */
/* S I E R R E U R : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : autrefois, la fonction 'Iload_fichier(...)' etait situee ici a cause de */
/* 'SYSTEME_ES9000_AIX_CC'. En effet, la compilation donnait un certain nombre de messages */
/* de warning du type : */
/* */
/* Passing an argument of type "int*" where "unsigned char[]" is expected. */
/* Passing an argument of type "double*" where "unsigned char[]"... */
/* Passing an argument of type "struct nombre_complexe*" where "unsigned char[]"... */
/* */
/* La seule solution simple (en l'absence de l'utilisation de pointeurs) est donc de mettre */
/* la definition de la fonction 'Iload_fichier(...)' a la fin, ce qui ne permet plus au */
/* compilateur de tester le type des arguments lors des appels a 'Iload_fichier(...)'... */
/* */
/* Puis l'arrivee de 'SYSTEME_SGIND?GA_IRIX_CC' a contraint de la remettre en tete ; en */
/* effet, rencontrer une fonction qui n'a pas encore ete definie lui donne implicitement */
/* le type 'int'. Or la fonction 'Iload_fichier(...)' a le type 'Int', d'ou les messages */
/* d'erreur du compilateur : */
/* */
/* cfe: Error: ...: redeclaration of 'Iload_fichier'; previous declaration at ... */
/* cfe: Error: ...: Incompatible function return type for this function. */
/* */
/* dont on ne peut se debarasser, meme avec des "cast"... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A R C H I V A G E D ' U N F I C H I E R D A N S L E P I P E S I L E N O M E S T */
/* V I D E O U S I N O N D A N S L E D I R E C T O R Y " i m a g e s " : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : autrefois, la fonction 'Istore_fichier(...)' etait situee ici a cause de */
/* 'SYSTEME_ES9000_AIX_CC'. En effet, la compilation donnait un certain nombre de messages */
/* de warning du type : */
/* */
/* Passing an argument of type "int*" where "unsigned char[]" is expected. */
/* Passing an argument of type "double*" where "unsigned char[]"... */
/* Passing an argument of type "struct nombre_complexe*" where "unsigned char[]"... */
/* */
/* La seule solution simple (en l'absence de l'utilisation de pointeurs) est donc de mettre */
/* la definition de la fonction 'Istore_fichier(...)' a la fin, ce qui ne permet plus au */
/* compilateur de tester le type des arguments lors des appels a 'Istore_fichier(...)'... */
/* */
/* Puis l'arrivee de 'SYSTEME_SGIND?GA_IRIX_CC' a contraint de la remettre en tete ; en */
/* effet, rencontrer une fonction qui n'a pas encore ete definie lui donne implicitement */
/* le type 'int'. Or la fonction 'Istore_fichier(...)' a le type 'Int', d'ou les messages */
/* d'erreur du compilateur : */
/* */
/* cfe: Error: ...: redeclaration of 'Istore_fichier'; previous declaration at ... */
/* cfe: Error: ...: Incompatible function return type for this function. */
/* */
/* dont on ne peut se debarasser, meme avec des "cast"... */
#undef EXECUTE_PLUSIEURS_FONCTIONS
#undef NOM_FICHIER
#undef ON_NE_SAIT_PAS_SI_NOM_FICHIER_DESIGNE_UNE_PALETTE_OU_UNE_IMAGE
#undef NOM_FICHIER_DESIGNE_UNE_PALETTE
_______________________________________________________________________________________________________________________________________
_______________________________________________________________________________________________________________________________________
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S A L B U M S : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(GdAload_album_____inverser_numeros,FAUX)));
DEFV(Common,DEFV(Logical,ZINT(GdAupdate_album_____inverser_numeros,FAUX)));
/* Introduits le 20181101120955 pour permettre l'inversion de l'ordre des images d'un */
/* album lors d'un 'GdAload_album(...)' et d'un 'GdAupdate_album(..)'... */
_______________________________________________________________________________________________________________________________________