/*************************************************************************************************************************************/
/* */
/* R E M P L I S S A G E D E T O U S L E S C O N T O U R S D ' U N A L B U M : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande permet d'extraire */
/* tous les contours contenus dans un album */
/* Argument et de les remplir. */
/* */
/* */
/* Author of '$xci/contours.32$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20231201130923). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
#include image_image_CONTOURS_EXT
#include image_image_DI_ALBUM_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
/* ATTENTION, on definit ainsi le symbole 'DERNIERE_IMAGE' qui ne sert a rien ici, puisque */
/* c'est en effet 'Zmax' qui joue ce role... */
#define INVERSER_L_AXE_OZ \
FAUX \
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */ \
/* */ \
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */ \
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */ \
/* */
#define INCOMPLET_AXE_OZ \
FAUX \
/* Indique s'il peut manquer des images... */
#define INCOMPLET_AXE_OZ_VALEUR_STANDARD \
NOIR \
/* Donne la valeur des images manquantes... */
#define COMPLEMENTER_L_ALBUM \
FAUX \
/* Faut-il complementer l'album dont on veut remplir tous les contours. */
#define PARCOURS_dc__6 \
VRAI
#define PARCOURS_dc__5 \
VRAI
#define PARCOURS_dc_4_ \
VRAI
#define PARCOURS_dc_46 \
FAUX
#define PARCOURS_dc_45 \
FAUX
#define PARCOURS_dc_2_ \
VRAI
#define PARCOURS_dc_26 \
FAUX
#define PARCOURS_dc_25 \
FAUX
#define PARCOURS_dc3__ \
VRAI
#define PARCOURS_dc3_6 \
FAUX
#define PARCOURS_dc3_5 \
FAUX
#define PARCOURS_dc34_ \
FAUX
#define PARCOURS_dc346 \
FAUX
#define PARCOURS_dc345 \
FAUX
#define PARCOURS_dc32_ \
FAUX
#define PARCOURS_dc326 \
FAUX
#define PARCOURS_dc325 \
FAUX
#define PARCOURS_dc1__ \
VRAI
#define PARCOURS_dc1_6 \
FAUX
#define PARCOURS_dc1_5 \
FAUX
#define PARCOURS_dc14_ \
FAUX
#define PARCOURS_dc146 \
FAUX
#define PARCOURS_dc145 \
FAUX
#define PARCOURS_dc12_ \
FAUX
#define PARCOURS_dc126 \
FAUX
#define PARCOURS_dc125 \
FAUX
/* Pour choisir les directions de parcours... */
#define UTILISER_LA_TAILLE_DES_CONTOURS_COMME_NIVEAU_DE_REMPLISSAGE \
FAUX
#define A_FACTEUR_DE_LA_TAILLE_DES_CONTOURS \
GRO2(FRA10(FRA10(FU)))
#define B_FACTEUR_DE_LA_TAILLE_DES_CONTOURS \
FLOT(GRIS_3)
/* Afin de pouvoir remplir chaque contour avec sa taille. */
#define UTILISER_LE_NIVEAU_MAJORITAIRE_AU_BORD_COMME_NIVEAU_DE_REMPLISSAGE \
FAUX \
/* Afin de pouvoir remplir chaque contour avec la niveau le plus represente sur son 'bord'. */
#define UTILISER_LE_NIVEAU_MAXIMAL_D_UN_POINT_ISOLE_COMME_NIVEAU_DE_REMPLISSAGE \
FAUX \
/* Afin de pouvoir remplir chaque contour avec la niveau maximal d'un point isole du fond. */
#define NIVEAU_INITIAL_DE_REMPLISSAGE_DES_CONTOURS \
NOIR_PLANCHER
#define INCREMENT_DU_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS \
FU
/* Definition incrementale des niveaux de remplissage... */
#define LE_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_EST_ALEATOIRE \
FAUX
#define GRAINE_DU_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_ALEATOIRE \
PARE(1789)
#define LE_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_EST_ALEATOIRE_ET_MULTIPLE_DE \
FU
/* Definition incrementale des niveaux de remplissage dans le cas ou cela est aleatoire. */
#define AVERTIR_LORSQU_IL_N_Y_A_PAS_ASSEZ_DE_COULEURS \
FAUX \
/* Faut-il avertir lorsqu'il n'y a pas assez de couleurs (moins que de contours...) ? */
#define EDITER_LES_INFORMATIONS_RELATIVES_A_CHAQUE_CONTOUR_REMPLI \
FAUX \
/* Faut-il editer les informations relatives a chaque contour rempli ? */
#define EDITER_LE_NOMBRE_DE_CONTOURS_REMPLIS_ET_L_INCREMENT_OPTIMAL \
FAUX \
/* Faut-il editer le nombre de contours remplis ? */
#define OPTIMISER_AUTOMATIQUEMENT_L_INCREMENT \
FAUX \
/* Faut-il calculer l'increment optimal ? */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define DEFINE_CONTOUR(logique1,logique2) \
Bblock \
BoIn(niveau,NOIR,seuil_de_limite_entre_l_interieur_et_l_exterieur,PAS_COULEURS) \
Bblock \
EGAL(ITb1(fond,INDX(niveau,NOIR)),logique1); \
EGAL(ITb1(bord,INDX(niveau,NOIR)),logique2); \
Eblock \
EBoI \
\
BoIn(niveau,SUCN(seuil_de_limite_entre_l_interieur_et_l_exterieur),BLANC,PAS_COULEURS) \
Bblock \
EGAL(ITb1(fond,INDX(niveau,NOIR)),logique2); \
EGAL(ITb1(bord,INDX(niveau,NOIR)),logique1); \
Eblock \
EBoI \
Eblock \
/* Definition de l'interieur et de l'exterieur d'un contour. */
#define GENERATION_NIVEAU_ALEATOIRE_DE_REMPLISSAGE(niveau_aleatoire_de_remplissage) \
Bblock \
EGAL(niveau_aleatoire_de_remplissage \
,rdnF2D(ADRESSE(point_courant_de_l_espace_de_parametrage) \
,graine_du_niveau_de_remplissage_des_contours_aleatoire \
,RDN_INIT_AND_GENERE \
,FLOT(NOIR_PLANCHER),FLOT__BLANC \
) \
); \
/* Generation d'un niveau aleatoire dans [NOIR_PLANCHER,BLANC] et parametre par le point */ \
/* courant de l'espace de parametrage. */ \
\
SPIRALE_INITIALISATION; \
/* Initialisation dynamique de 'spirale_nombre_de_points_a_traiter'. */ \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage,x) \
,ASD1(point_courant_de_l_espace_de_parametrage,y) \
); \
/* Deplacement du point courant de la spirale de l'espace de parametrage. */ \
SPIRALE_PARCOURS; \
/* Parcours de la spirale avec rotation eventuelle de PI/2 du bras courant... */ \
Eblock \
/* Generation d'un niveau aleatoire de remplissage... */
#define REMPLISSAGE_DU_CONTOUR_COURANT(niveau_de_remplissage) \
Bblock \
CALi(dAnoir(AlbumTemporaire2)); \
\
CALS(Aremplissage(AlbumTemporaire2 \
,AlbumTemporaire1 \
,AlbumMarqueur \
,ADRESSE(point_courant) \
,ADRESSE(coin_inferieur_gauche_avant) \
,ADRESSE(coin_superieur_droite_arriere) \
,fond,bord \
,parcours_dc__6 \
,parcours_dc__5 \
,parcours_dc_4_ \
,parcours_dc_46 \
,parcours_dc_45 \
,parcours_dc_2_ \
,parcours_dc_26 \
,parcours_dc_25 \
,parcours_dc3__ \
,parcours_dc3_6 \
,parcours_dc3_5 \
,parcours_dc34_ \
,parcours_dc346 \
,parcours_dc345 \
,parcours_dc32_ \
,parcours_dc326 \
,parcours_dc325 \
,parcours_dc1__ \
,parcours_dc1_6 \
,parcours_dc1_5 \
,parcours_dc14_ \
,parcours_dc146 \
,parcours_dc145 \
,parcours_dc12_ \
,parcours_dc126 \
,parcours_dc125 \
,GENP(niveau_de_remplissage) \
) \
); \
Eblock \
/* Remplissage d'un contour. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E M P L I S S A G E D E T O U S L E S C O N T O U R S D ' U N A L B U M : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_albumR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_albumA),NOM_PIPE));
/* Afin de pouvoir remplir chaque contour avec un niveau preleve dans une image auxiliaire */
/* de "Texturage" au point correspondant au point de depart. */
DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_albumA><numero> (par exemple '$ROUGE'). */
DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
/* Numero de la premiere image, */
DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la serie... */
DEFV(Logical,INIT(inverser_l_axe_OZ,INVERSER_L_AXE_OZ));
/* Indique s'il faut inverser l'ordre de parcours de l'ensemble des images. On a : */
/* */
/* FAUX : l'image d'arriere-plan est la premiere de la liste, */
/* VRAI : l'image d'arriere-plan est la derniere de la liste. */
/* */
DEFV(Logical,INIT(incomplet_axe_OZ,INCOMPLET_AXE_OZ));
/* Indique s'il peut manquer des images. */
DEFV(genere_p,INIT(incomplet_axe_OZ_valeur_standard,INCOMPLET_AXE_OZ_VALEUR_STANDARD));
/* Donne la valeur des images manquantes. */
DEFV(Logical,INIT(complementer_l_album,COMPLEMENTER_L_ALBUM));
/* Faut-il complementer l'album dont on veut remplir tous les contours ? */
DEFV(genere_p,INIT(seuil_de_limite_entre_l_interieur_et_l_exterieur,NIVEAU_UNDEF));
/* Seuil de limite entre l'interieur et l'exterieur des contours. */
DEFV(Logical,DTb1(fond,COULEURS));
/* Definition du fond (ce que l'on doit remplir). */
DEFV(Logical,DTb1(bord,COULEURS));
/* Et du bord (ce qui definit le contour et son exterieur). */
DEFV(Logical,INIT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage
,UTILISER_LA_TAILLE_DES_CONTOURS_COMME_NIVEAU_DE_REMPLISSAGE
)
);
DEFV(Float,INIT(A_facteur_de_la_taille_des_contours,A_FACTEUR_DE_LA_TAILLE_DES_CONTOURS));
DEFV(Float,INIT(B_facteur_de_la_taille_des_contours,B_FACTEUR_DE_LA_TAILLE_DES_CONTOURS));
/* Afin de pouvoir remplir chaque contour avec sa taille. */
DEFV(Logical,INIT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage
,UTILISER_LE_NIVEAU_MAJORITAIRE_AU_BORD_COMME_NIVEAU_DE_REMPLISSAGE
)
);
/* Afin de pouvoir remplir chaque contour avec la niveau le plus represente sur son 'bord'. */
DEFV(Logical,INIT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage
,UTILISER_LE_NIVEAU_MAXIMAL_D_UN_POINT_ISOLE_COMME_NIVEAU_DE_REMPLISSAGE
)
);
/* Afin de pouvoir remplir chaque contour avec la niveau maximal d'un point isole du fond. */
DEFV(Float,INIT(niveau_courant_de_remplissage_des_contours,FLOT__UNDEF));
DEFV(genere_p,INIT(niveau_initial_de_remplissage_des_contours,NIVEAU_INITIAL_DE_REMPLISSAGE_DES_CONTOURS));
DEFV(Float,INIT(increment_du_niveau_de_remplissage_des_contours,INCREMENT_DU_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS));
/* Definition incrementale des niveaux de remplissage... */
DEFV(Logical,INIT(le_niveau_de_remplissage_des_contours_est_aleatoire,LE_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_EST_ALEATOIRE));
DEFV(Int,INIT(graine_du_niveau_de_remplissage_des_contours_aleatoire,GRAINE_DU_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_ALEATOIRE));
DEFV(Float,INIT(le_niveau_de_remplissage_des_contours_est_aleatoire_et_multiple_de
,LE_NIVEAU_DE_REMPLISSAGE_DES_CONTOURS_EST_ALEATOIRE_ET_MULTIPLE_DE
)
);
DEFV(pointF_2D,point_courant_de_l_espace_de_parametrage);
SPIRALE_DEFINITION_GENERALE(SPIRALE_DELTA_HORIZONTAL_GLOBAL,SPIRALE_DELTA_VERTICAL_GLOBAL)
/* Definition incrementale des niveaux de remplissage dans le cas ou cela est aleatoire. */
DEFV(Logical,INIT(parcours_dc__6,PARCOURS_dc__6));
DEFV(Logical,INIT(parcours_dc__5,PARCOURS_dc__5));
DEFV(Logical,INIT(parcours_dc_4_,PARCOURS_dc_4_));
DEFV(Logical,INIT(parcours_dc_46,PARCOURS_dc_46));
DEFV(Logical,INIT(parcours_dc_45,PARCOURS_dc_45));
DEFV(Logical,INIT(parcours_dc_2_,PARCOURS_dc_2_));
DEFV(Logical,INIT(parcours_dc_26,PARCOURS_dc_26));
DEFV(Logical,INIT(parcours_dc_25,PARCOURS_dc_25));
DEFV(Logical,INIT(parcours_dc3__,PARCOURS_dc3__));
DEFV(Logical,INIT(parcours_dc3_6,PARCOURS_dc3_6));
DEFV(Logical,INIT(parcours_dc3_5,PARCOURS_dc3_5));
DEFV(Logical,INIT(parcours_dc34_,PARCOURS_dc34_));
DEFV(Logical,INIT(parcours_dc346,PARCOURS_dc346));
DEFV(Logical,INIT(parcours_dc345,PARCOURS_dc345));
DEFV(Logical,INIT(parcours_dc32_,PARCOURS_dc32_));
DEFV(Logical,INIT(parcours_dc326,PARCOURS_dc326));
DEFV(Logical,INIT(parcours_dc325,PARCOURS_dc325));
DEFV(Logical,INIT(parcours_dc1__,PARCOURS_dc1__));
DEFV(Logical,INIT(parcours_dc1_6,PARCOURS_dc1_6));
DEFV(Logical,INIT(parcours_dc1_5,PARCOURS_dc1_5));
DEFV(Logical,INIT(parcours_dc14_,PARCOURS_dc14_));
DEFV(Logical,INIT(parcours_dc146,PARCOURS_dc146));
DEFV(Logical,INIT(parcours_dc145,PARCOURS_dc145));
DEFV(Logical,INIT(parcours_dc12_,PARCOURS_dc12_));
DEFV(Logical,INIT(parcours_dc126,PARCOURS_dc126));
DEFV(Logical,INIT(parcours_dc125,PARCOURS_dc125));
/* Pour choisir les directions de parcours... */
DEFV(Logical,INIT(avertir_lorsqu_il_n_y_a_pas_assez_de_couleurs,AVERTIR_LORSQU_IL_N_Y_A_PAS_ASSEZ_DE_COULEURS));
/* Faut-il avertir lorsqu'il n'y a pas assez de couleurs (moins que de contours...) ? */
DEFV(Logical,INIT(editer_les_informations_relatives_a_chaque_contour_rempli
,EDITER_LES_INFORMATIONS_RELATIVES_A_CHAQUE_CONTOUR_REMPLI
)
);
/* Faut-il editer les informations relatives a chaque contour rempli ? */
DEFV(Logical,INIT(editer_le_nombre_de_contours_remplis_et_l_increment_optimal
,EDITER_LE_NOMBRE_DE_CONTOURS_REMPLIS_ET_L_INCREMENT_OPTIMAL
)
);
/* Faut-il editer le nombre de contours remplis ? */
DEFV(Logical,INIT(remplir_les_contours,VRAI));
DEFV(Logical,INIT(c_est_la_passe_d_optimisation_de_l_increment,LUNDEF));
DEFV(Logical,INIT(optimiser_automatiquement_l_increment,OPTIMISER_AUTOMATIQUEMENT_L_INCREMENT));
/* Faut-il calculer l'increment optimal ? */
/*..............................................................................................................................*/
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_albumA);
GET_ARGUMENT_C("imageR=""R=",nom_albumR);
GET_ARGUMENT_C("postfixe=",nom_postfixe);
GET_ARGUMENT_I("premiere=",premiere_image);
GET_ARGUMENTS2_I("pas=",pas_des_images,pasZ);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_L("complementer=""comp=",complementer_l_album);
GET_ARGUMENT_L("utiliser_taille=""taille=",utiliser_la_taille_des_contours_comme_niveau_de_remplissage);
GET_ARGUMENT_F("Afacteur_taille=""Afacteur=""Af=",A_facteur_de_la_taille_des_contours);
GET_ARGUMENT_F("Bfacteur_taille=""Bfacteur=""Bf=",B_facteur_de_la_taille_des_contours);
GET_ARGUMENT_L("utiliser_bord_majoritaire=""majoritaire="
,utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage
);
GET_ARGUMENT_L("utiliser_niveau_maximal_point_isole=""point_isole="
,utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage
);
GET_ARGUMENT_P("niveau_initial=""ni=",niveau_initial_de_remplissage_des_contours);
GET_ARGUMENT_F("increment_niveau=""in=",increment_du_niveau_de_remplissage_des_contours);
GET_ARGUMENT_L("niveau_aleatoire=""na=",le_niveau_de_remplissage_des_contours_est_aleatoire);
GET_ARGUMENT_I("graine_niveau_aleatoire=""graine=",graine_du_niveau_de_remplissage_des_contours_aleatoire);
GET_ARGUMENT_F("niveau_aleatoire_multiple=""nam="
,le_niveau_de_remplissage_des_contours_est_aleatoire_et_multiple_de
);
GET_ARGUMENT_I("methode=",gen_ft_____methode_standard);
GET_ARGUMENT_L("dc__6=",parcours_dc__6);
GET_ARGUMENT_L("dc__5=",parcours_dc__5);
GET_ARGUMENT_L("dc_4_=",parcours_dc_4_);
GET_ARGUMENT_L("dc_46=",parcours_dc_46);
GET_ARGUMENT_L("dc_45=",parcours_dc_45);
GET_ARGUMENT_L("dc_2_=",parcours_dc_2_);
GET_ARGUMENT_L("dc_26=",parcours_dc_26);
GET_ARGUMENT_L("dc_25=",parcours_dc_25);
GET_ARGUMENT_L("dc3__=",parcours_dc3__);
GET_ARGUMENT_L("dc3_6=",parcours_dc3_6);
GET_ARGUMENT_L("dc3_5=",parcours_dc3_5);
GET_ARGUMENT_L("dc34_=",parcours_dc34_);
GET_ARGUMENT_L("dc346=",parcours_dc346);
GET_ARGUMENT_L("dc345=",parcours_dc345);
GET_ARGUMENT_L("dc32_=",parcours_dc32_);
GET_ARGUMENT_L("dc326=",parcours_dc326);
GET_ARGUMENT_L("dc325=",parcours_dc325);
GET_ARGUMENT_L("dc1__=",parcours_dc1__);
GET_ARGUMENT_L("dc1_6=",parcours_dc1_6);
GET_ARGUMENT_L("dc1_5=",parcours_dc1_5);
GET_ARGUMENT_L("dc14_=",parcours_dc14_);
GET_ARGUMENT_L("dc146=",parcours_dc146);
GET_ARGUMENT_L("dc145=",parcours_dc145);
GET_ARGUMENT_L("dc12_=",parcours_dc12_);
GET_ARGUMENT_L("dc126=",parcours_dc126);
GET_ARGUMENT_L("dc125=",parcours_dc125);
GET_ARGUMENT_L("avertir_couleurs=""avertir=",avertir_lorsqu_il_n_y_a_pas_assez_de_couleurs);
GET_ARGUMENT_L("editer_informations=""informations="
,editer_les_informations_relatives_a_chaque_contour_rempli
);
GET_ARGUMENT_L("editer_nombre_contours_remplis=""editer="
,editer_le_nombre_de_contours_remplis_et_l_increment_optimal
);
GET_ARGUMENT_L("optimiser_increment=""optimiser=""oi=",optimiser_automatiquement_l_increment);
GET_ARGUMENT_L("editer_centres_gravite=""editer_centre_gravite=""ecg="
,Aremplissage_____editer_le_centre_de_gravite
);
)
);
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
Bblock
Eblock
ATes
Bblock
Test(IFEQ(niveau_initial_de_remplissage_des_contours,NOIR))
Bblock
PRINT_ERREUR("le niveau initial de remplissage ne peut etre le NOIR");
EGAL(niveau_initial_de_remplissage_des_contours,SUCN(niveau_initial_de_remplissage_des_contours));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(IFET(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage)
,IFOU(IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
)
Bblock
PRINT_ATTENTION("la taille des contours l'emporte sur sur les autres methodes");
EGAL(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage,FAUX);
EGAL(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage,FAUX);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
Bblock
PRINT_ATTENTION("la recherche du niveau majoritaire du bord l'emporte sur sur les autres methodes");
EGAL(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage,FAUX);
Eblock
ATes
Bblock
Eblock
ETes
EGAL(seuil_de_limite_entre_l_interieur_et_l_exterieur,PREN(niveau_initial_de_remplissage_des_contours));
/* Seuil de limite entre l'interieur et l'exterieur des contours. */
Test(IFGE(seuil_de_limite_entre_l_interieur_et_l_exterieur,BLANC))
Bblock
PRINT_ERREUR("le seuil de limite entre l'interieur et l'exterieur doit etre inferieur au niveau maximal");
EGAL(seuil_de_limite_entre_l_interieur_et_l_exterieur,PREN(BLANC));
Eblock
ATes
Bblock
Eblock
ETes
begin_nouveau_block
Bblock
BDEFV(album,AlbumArgument);
BDEFV(album,AlbumContours);
BDEFV(album,AlbumMarqueur);
BDEFV(album,AlbumTemporaire1);
BDEFV(album,AlbumTemporaire2);
BDEFV(album,AlbumRemplissage);
CALi(idAload_album(AlbumArgument
,nom_albumA
,nom_postfixe
,premiere_image
,pas_des_images
,nombre_de_chiffres
,FAUX
,UNDEF
,inverser_l_axe_OZ
,incomplet_axe_OZ
,incomplet_axe_OZ_valeur_standard
)
);
/* Chargement de l'album Argument... */
Test(PAS_D_ERREUR(CODE_ERREUR))
Bblock
DEFV(Int,INIT(compteur_des_contours,ZERO));
/* Compteur des contours remplis. On notera que l'on ne connait pas a priori le nombre */
/* de contours a extraire... */
DEFV(pointF_3D,coin_inferieur_gauche_avant);
/* Coin inferieur gauche de la zone de remplissage, */
DEFV(pointF_3D,coin_superieur_droite_arriere);
/* Coin superieur droite de la zone de remplissage. */
Test(IL_FAUT(complementer_l_album))
Bblock
CALS(dAcomplementation(AlbumContours,AlbumArgument));
Eblock
ATes
Bblock
CALS(Amove(AlbumContours,AlbumArgument));
Eblock
ETes
INITIALISATION_POINT_3D(coin_inferieur_gauche_avant,CADRE_GAUCHE,CADRE_INFERIEUR,CADRE_AVANT);
/* Definition du coin inferieur gauche de remplissage, */
INITIALISATION_POINT_3D(coin_superieur_droite_arriere,CADRE_DROITE,CADRE_SUPERIEUR,CADRE_ARRIERE);
/* Definition du coin superieur droite de remplissage. */
DEFINE_CONTOUR(VRAI,FAUX);
/* Definition de l'interieur et de l'exterieur du contour... */
Test(IL_FAUT(optimiser_automatiquement_l_increment))
Bblock
EGAL(c_est_la_passe_d_optimisation_de_l_increment,VRAI);
Eblock
ATes
Bblock
Eblock
ETes
Tant(IL_FAUT(remplir_les_contours))
Bblock
CLIR(compteur_des_contours);
Test(EST_VRAI(le_niveau_de_remplissage_des_contours_est_aleatoire))
Bblock
DEFV(Float,INIT(niveau_initial_aleatoire_de_remplissage_des_contours,FLOT__UNDEF));
SPIRALE_VALIDATION;
INITIALISATION_POINT_2D(point_courant_de_l_espace_de_parametrage,FLOT(Xmin),FLOT(Ymin));
GENERATION_NIVEAU_ALEATOIRE_DE_REMPLISSAGE(niveau_initial_aleatoire_de_remplissage_des_contours);
EGAL(niveau_initial_de_remplissage_des_contours,GENP(niveau_initial_aleatoire_de_remplissage_des_contours));
Eblock
ATes
Bblock
Eblock
ETes
EGAL(niveau_courant_de_remplissage_des_contours,FLOT(niveau_initial_de_remplissage_des_contours));
CALi(dAnoir(AlbumRemplissage));
CALi(Amove(AlbumTemporaire1,AlbumContours));
begin_album
Bblock
DEFV(genere_p,INIT(niveau_courant,Aload_point(AlbumTemporaire1,X,Y,Z)));
DEFV(pointF_3D,point_courant);
/* Point de depart de l'extraction de contour. */
Test(IFET(EST_VRAI(ITb1(fond,INDX(niveau_courant,NOIR)))
,EST_FAUX(ITb1(bord,INDX(niveau_courant,NOIR)))
)
)
/* Ainsi, on se place sur le premier point {X,Y,Z} qui appartient au fond et qui est */
/* eventuellement marque... */
Bblock
DEFV(Float,INIT(prochain_niveau_courant_de_remplissage_des_contours,FLOT__UNDEF));
INITIALISATION_POINT_3D(point_courant,_____cNORMALISE_OX(X),_____cNORMALISE_OY(Y),_____cNORMALISE_OZ(Z));
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
Bblock
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
EGAL(niveau_courant_de_remplissage_des_contours
,AXPB(A_facteur_de_la_taille_des_contours
,Aremplissage_voisinage_____nombre_de_points_du__fond
,B_facteur_de_la_taille_des_contours
)
);
/* Ainsi lors du "vrai" remplissage (celui qui suit), le niveau de remplissage sera */
/* fonction du nombre de points de ce contour. On notera malgre tout un petit probleme : */
/* celui des contours partiellement hors de l'image... */
Test(IFLT(niveau_courant_de_remplissage_des_contours,SUCN(FLOT__BLANC)))
Bblock
Eblock
ATes
Bblock
EGAL(niveau_courant_de_remplissage_des_contours,FLOT__BLANC);
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage))
Bblock
BSaveModifyVariable(Logical
,Aremplissage_____calculer_l_histogramme_du__bord
,utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage
);
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
begin_nouveau_block
Bblock
DEFV(Int,INIT(compteur_maximal,ZERO));
DEFV(genere_p,INIT(niveau_maximal,NIVEAU_UNDEF));
/* Afin de rechercher le niveau qui correspond au compteur maximal... */
BoIn(niveau,NOIR,BLANC,PAS_COULEURS)
Bblock
Test(IFGE(ACCES_HISTOGRAMME(niveau),compteur_maximal))
Bblock
EGAL(compteur_maximal,ACCES_HISTOGRAMME(niveau));
EGAL(niveau_maximal,niveau);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EBoI
EGAL(niveau_courant_de_remplissage_des_contours,FLOT(niveau_maximal));
Eblock
end_nouveau_block
ESaveModifyVariable(Logical
,Aremplissage_____calculer_l_histogramme_du__bord
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage))
Bblock
begin_nouveau_block
Bblock
BSaveModifyVariable(Logical
,Aremplissage_voisinage_____rechercher_le_niveau_maximal_d_un_point_isole
,utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage
);
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
EGAL(niveau_courant_de_remplissage_des_contours
,MAX2(Aremplissage_voisinage_____niveau_maximal_d_un_point_isole,FLOT(NOIR_PLANCHER))
);
ESaveModifyVariable(Logical
,Aremplissage_voisinage_____rechercher_le_niveau_maximal_d_un_point_isole
);
Eblock
end_nouveau_block
Eblock
ATes
Bblock
Eblock
ETes
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
/* Remplissage du contour courant... */
INCR(compteur_des_contours,I);
/* Comptage des contours... */
Test(IL_FAUT(editer_les_informations_relatives_a_chaque_contour_rempli))
Bblock
CAL3(Prme1("NumeroContour=%d ",compteur_des_contours));
CAL3(Prme1("NombrePoints=%d ",Aremplissage_voisinage_____nombre_de_points_du__fond));
CAL3(Prme2("Niveau=%d (%f) "
,GENP(niveau_courant_de_remplissage_des_contours)
,niveau_courant_de_remplissage_des_contours
)
);
CAL3(Prme3("Point={%+.^^^,%+.^^^,%+.^^^}"
,ASD1(point_courant,x)
,ASD1(point_courant,y)
,ASD1(point_courant,z)
)
);
CAL3(Prme0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
CALS(dAor(AlbumTemporaire1,AlbumTemporaire1,AlbumTemporaire2));
/* Ainsi, 'AlbumTemporaire1' contient les contours initiaux a remplir plus au fur et a */
/* mesure tous les remplissages (et ce afin de pouvoir trouver le prochain point {X,Y,Z} du */
/* fond). */
CALS(dAor(AlbumRemplissage,AlbumRemplissage,AlbumTemporaire2));
/* Cumul du remplissage courant en vue du Resultat... */
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
Bblock
Eblock
ATes
Bblock
Test(EST_VRAI(le_niveau_de_remplissage_des_contours_est_aleatoire))
Bblock
GENERATION_NIVEAU_ALEATOIRE_DE_REMPLISSAGE(prochain_niveau_courant_de_remplissage_des_contours);
EGAL(prochain_niveau_courant_de_remplissage_des_contours
,MULTIPLE1(prochain_niveau_courant_de_remplissage_des_contours
,le_niveau_de_remplissage_des_contours_est_aleatoire_et_multiple_de
)
);
Eblock
ATes
Bblock
EGAL(prochain_niveau_courant_de_remplissage_des_contours
,ADD2(niveau_courant_de_remplissage_des_contours
,increment_du_niveau_de_remplissage_des_contours
)
);
Eblock
ETes
Test(IL_FAUT(optimiser_automatiquement_l_increment))
Bblock
/* La validation a suivre n'a pas d'interet dans ce cas... */
Eblock
ATes
Bblock
Test(IFLT(prochain_niveau_courant_de_remplissage_des_contours,SUCN(FLOT__BLANC)))
Bblock
Eblock
ATes
Bblock
Test(IZNE(CALS(Icomptage_des_points_dans_un_intervalle
(AlbumTemporaire1
,PREN(niveau_initial_de_remplissage_des_contours)
,PREN(niveau_initial_de_remplissage_des_contours)
)
)
)
)
/* Je note le 20161104095242 que ce cas peut se rencontrer tout en etant normal : c'est */
/* le cas lorsque il n'y a pas de prochain contour (tout a ete rempli). Ce fut le cas */
/* avec l'image 'v $xiirv/TROR.54' qui possede 752 contours... */
/* */
/* Le 20231128101918, j'ai du mal a comprendre ce test qui finalement a fait disparaitre */
/* la gestion "modulo" des niveaux. D'ou les modifications du 20231128101918... */
Bblock
Test(IL_FAUT(avertir_lorsqu_il_n_y_a_pas_assez_de_couleurs))
Bblock
PRINT_ERREUR("il y a plus de contours que de couleurs disponibles");
CAL1(Prer1("(contour courant numero %d)\n",compteur_des_contours));
Eblock
ATes
Bblock
Eblock
ETes
EGAL(prochain_niveau_courant_de_remplissage_des_contours
,NEUT(niveau_initial_de_remplissage_des_contours)
);
/* A compter du 20161102113914, les niveaux sont geres "modulo"... */
Eblock
ATes
Bblock
EGAL(prochain_niveau_courant_de_remplissage_des_contours
,niveau_initial_de_remplissage_des_contours
);
Eblock
ETes
Eblock
ETes
Eblock
ETes
EGAL(niveau_courant_de_remplissage_des_contours,prochain_niveau_courant_de_remplissage_des_contours);
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_album
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
Bblock
EGAL(remplir_les_contours,FAUX);
Eblock
ATes
Bblock
Test(IL_FAUT(optimiser_automatiquement_l_increment))
Bblock
Test(EST_VRAI(c_est_la_passe_d_optimisation_de_l_increment))
Bblock
EGAL(increment_du_niveau_de_remplissage_des_contours
,DIVI(FLOT(SOUS(PREN(COULEURS)
,SOUS(niveau_initial_de_remplissage_des_contours
,NIVEAU_INITIAL_DE_REMPLISSAGE_DES_CONTOURS
)
)
)
,FLOT(compteur_des_contours)
)
);
EGAL(c_est_la_passe_d_optimisation_de_l_increment,FAUX);
Eblock
ATes
Bblock
EGAL(remplir_les_contours,FAUX);
Eblock
ETes
Eblock
ATes
Bblock
EGAL(remplir_les_contours,FAUX);
Eblock
ETes
Eblock
ETes
Eblock
ETan
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
Bblock
Eblock
ATes
Bblock
Test(IZGT(compteur_des_contours))
Bblock
Test(IL_FAUT(editer_le_nombre_de_contours_remplis_et_l_increment_optimal))
Bblock
CAL3(Prme1("NombreContoursRemplis=%d\n",compteur_des_contours));
CAL3(Prme1("IncrementOptimal=%+.^^^\n",DIVI(FLOT(PREN(COULEURS)),FLOT(compteur_des_contours))));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ATTENTION("aucun contour n'a ete rempli");
Eblock
ETes
Eblock
ETes
CALi(dAupdate_album(nom_albumR
,nom_postfixe
,premiere_image
,pas_des_images
,AlbumRemplissage
,nombre_de_chiffres
,FAUX
)
);
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
EDEFV(album,AlbumRemplissage);
EDEFV(album,AlbumTemporaire2);
EDEFV(album,AlbumTemporaire1);
EDEFV(album,AlbumMarqueur);
EDEFV(album,AlbumContours);
EDEFV(album,AlbumArgument);
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande