/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande permet d'extraire */
/* tous les contours contenus dans une image */
/* Argument et de les remplir. */
/* */
/* */
/* Author of '$xci/contours.22$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20161027172653). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define COMPLEMENTER_L_IMAGE \
FAUX \
/* Faut-il complementer l'image dont on veut remplir tous les contours (introduit */ \
/* le 20231128092920) ? */
#define PARCOURS___EST \
VRAI
#define PARCOURS__NORD \
VRAI
#define PARCOURS_OUEST \
VRAI
#define PARCOURS___SUD \
VRAI
#define PARCOURS__NORD___EST \
VRAI
#define PARCOURS__NORD_OUEST \
VRAI
#define PARCOURS___SUD_OUEST \
VRAI
#define PARCOURS___SUD___EST \
VRAI
/* Pour choisir les directions de parcours... */
#define CHOISIR_LE_NIVEAU_DE_REMPLISSAGE_DANS_UNE_IMAGE_DE_TEXTURAGE \
FAUX \
/* Afin de pouvoir remplir chaque contour avec un niveau preleve dans une image auxiliaire */ \
/* de "Texturage" au point correspondant au point de depart (introduit le 20220121141035). */ \
/* La valeur 'FAUX' par defaut garantit la compatibilite anterieure... */
#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 (introduit le 20170530150522). */
#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' */ \
/* (introduit le 20230823133343). */
#define UTILISER_LA_MATRICE_D_INERTIE_POUR_DEFINIR_LE_NIVEAU_DE_REMPLISSAGE \
FAUX
#define FACTEUR_____VECTEUR_PROPRE \
SOUS(DIVI(FLOT(COULEURS),CERCLE_TRIGONOMETRIQUE),FHUIT)
#define TRANSLATION_VECTEUR_PROPRE \
FU
/* Afin de pouvoir remplir chaque contour a partir des vecteurs propres de la matrice */
/* d'inertie (introduit le 20230825115100). */
#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 */ \
/* (introduit le 20230827094130). */
#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 */
/* (introduit le 20181225173548 et complete le 20231010093951...). */
#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...) */ \
/* (introduit le 20170530133136) ? */
#define EDITER_LES_INFORMATIONS_RELATIVES_A_CHAQUE_CONTOUR_REMPLI \
FAUX \
/* Faut-il editer les informations relatives a chaque contour rempli (introduit le */ \
/* 20230814113953) ? */
#define EDITER_LE_NOMBRE_DE_CONTOURS_REMPLIS_ET_L_INCREMENT_OPTIMAL \
FAUX \
/* Faut-il editer le nombre de contours remplis (introduit le 20161101095640) ? */
#define OPTIMISER_AUTOMATIQUEMENT_L_INCREMENT \
FAUX \
/* Faut-il calculer l'increment optimal (introduit le 20161114130029) ? */
#define COMPATIBILITE_20180711 \
FAUX \
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */ \
/* au 20180711115638. */
#define COMPATIBILITE_20231121 \
FAUX \
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */ \
/* au 20231121152154. */ \
/* */ \
/* Je rappelle le 20240103111425 que c'est cette option de compatibilite qui permet de */ \
/* forcer le premier niveau aleatoire et donc de refaire, par exemple, 'v $xiirv/SMIT.91' */ \
/* qui possede un fond NOIR (via la palette 'v $xiio/MIRE p=$xiP/random.E5')... */
#define COMPATIBILITE_2023112810 \
FAUX \
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */ \
/* au 20231128101918. */
#define COMPATIBILITE_2023112811 \
FAUX \
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */ \
/* au 20231128111230. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define ImageArgument \
ImageA
#define ImageContours \
ImageA1
#define ImageTemporaire1 \
ImageA2
#define ImageTemporaire2 \
ImageA3
#define ImageMarqueur \
ImageA4
#define ImageTexture \
ImageA5
#define ImageRemplissage \
ImageR
#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 (introduit le 20231121152154)... */
#define MARQUEUR_D_INTERIEUR_DE_CONTOURS \
BLANC \
/* Niveau a utiliser pour reperer l'interieur des contours si besoin est (introduit le */ \
/* 20161118100552)... */
#define REMPLISSAGE_DU_CONTOUR_COURANT(niveau_de_remplissage) \
Bblock \
CALi(Inoir(ImageTemporaire2)); \
\
CALS(Iremplissage(ImageTemporaire2 \
,ImageTemporaire1 \
,ADRESSE(point_courant) \
,ADRESSE(coin_inferieur_gauche) \
,ADRESSE(coin_superieur_droite) \
,fond,bord \
,parcours___est,parcours__nord,parcours_ouest,parcours___sud \
,parcours__nord___est,parcours__nord_ouest,parcours___sud_ouest,parcours___sud___est \
,GENP(niveau_de_remplissage) \
) \
); \
Eblock \
/* Remplissage d'un contour (introduit sous cette forme le 20170530150522...). */
#define Ixx \
ASD2(Iremplissage_voisinage_____matrice_d_inertie_du__fond,cx,cx)
#define Ixy \
ASD2(Iremplissage_voisinage_____matrice_d_inertie_du__fond,cx,cy)
#define Iyx \
ASD2(Iremplissage_voisinage_____matrice_d_inertie_du__fond,cy,cx)
#define Iyy \
ASD2(Iremplissage_voisinage_____matrice_d_inertie_du__fond,cy,cy)
/* Definition des quatre moments d'inertie. */
#define cA \
FU
#define cB \
NEGA(ADD2(Ixx,Iyy))
#define cC \
SOUS(MUL2(Ixx,Iyy),MUL2(Ixy,Iyx))
/* Definition de l'equation du second degre donnant les valeurs propres de la matrice */
/* d'inertie... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageM),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageT),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 (introduit le 20220121141035). */
DEFV(Logical,INIT(complementer_l_image,COMPLEMENTER_L_IMAGE));
/* Faut-il complementer l'image dont on veut remplir tous les contours (introduit */
/* le 20231128092920) ? */
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(genere_p,INIT(marqueur_d_interieur_de_contours,MARQUEUR_D_INTERIEUR_DE_CONTOURS));
/* Niveau a utiliser pour reperer l'interieur des contours si besoin est (introduit le */
/* 20190713132526 sous cette forme...). */
DEFV(Logical,INIT(choisir_le_niveau_de_remplissage_dans_une_image_de_texturage
,CHOISIR_LE_NIVEAU_DE_REMPLISSAGE_DANS_UNE_IMAGE_DE_TEXTURAGE
)
);
/* Afin de pouvoir remplir chaque contour avec un niveau preleve dans une image auxiliaire */
/* de "Texturage" au point correspondant au point de depart (introduit le 20220121141035). */
/* La valeur 'FAUX' par defaut garantit la compatibilite anterieure... */
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 (introduit le 20170530150522). */
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' */
/* (introduit le 20230823133343). */
DEFV(Logical,INIT(utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage
,UTILISER_LA_MATRICE_D_INERTIE_POUR_DEFINIR_LE_NIVEAU_DE_REMPLISSAGE
)
);
DEFV(Float,INIT(facteur_____vecteur_propre,FACTEUR_____VECTEUR_PROPRE));
DEFV(Float,INIT(translation_vecteur_propre,TRANSLATION_VECTEUR_PROPRE));
/* Afin de pouvoir remplir chaque contour a partir des vecteurs propres de la matrice */
/* d'inertie (introduit le 20230825115100). */
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 */
/* (introduit le 20230827094130). */
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... */
/* */
/* Le 20161028101211, le niveau courant et son increment sont passes en 'Float' de facon */
/* a disposer, si besoin est, de suffisamment de niveaux dans [NOIR_PLANCHER,BLANC]... */
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 */
/* (introduit le 20181225173548)... */
DEFV(Logical,INIT(parcours___est,PARCOURS___EST));
DEFV(Logical,INIT(parcours__nord,PARCOURS__NORD));
DEFV(Logical,INIT(parcours_ouest,PARCOURS_OUEST));
DEFV(Logical,INIT(parcours___sud,PARCOURS___SUD));
DEFV(Logical,INIT(parcours__nord___est,PARCOURS__NORD___EST));
DEFV(Logical,INIT(parcours__nord_ouest,PARCOURS__NORD_OUEST));
DEFV(Logical,INIT(parcours___sud_ouest,PARCOURS___SUD_OUEST));
DEFV(Logical,INIT(parcours___sud___est,PARCOURS___SUD___EST));
/* 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...) */
/* (introduit le 20170530133136) ? */
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 (introduit le */
/* 20230814113953) ? */
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 (introduit le 20161101095640) ? */
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 (introduit le 20161114130029) ? */
DEFV(Logical,INIT(compatibilite_20180711,COMPATIBILITE_20180711));
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */
/* au 20180711115638. */
DEFV(Logical,INIT(compatibilite_20231121,COMPATIBILITE_20231121));
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */
/* au 20231121152154. */
/* */
/* Je rappelle le 20240103111425 que c'est cette option de compatibilite qui permet de */
/* forcer le premier niveau aleatoire et donc de refaire, par exemple, 'v $xiirv/SMIT.91' */
/* qui possede un fond NOIR (via la palette 'v $xiio/MIRE p=$xiP/random.E5')... */
DEFV(Logical,INIT(compatibilite_2023112810,COMPATIBILITE_2023112810));
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */
/* au 20231128101918. */
DEFV(Logical,INIT(compatibilite_2023112811,COMPATIBILITE_2023112811));
/* Permet de proceder a des calculs compatibles a ceux qui furent effectues anterieurement */
/* au 20231128111230. */
/*..............................................................................................................................*/
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20180711=",compatibilite_20180711);
GET_ARGUMENT_L("compatibilite_20231121=",compatibilite_20231121);
GET_ARGUMENT_L("compatibilite_2023112810=",compatibilite_2023112810);
GET_ARGUMENT_L("compatibilite_2023112811=",compatibilite_2023112811);
GET_ARGUMENT_C("imageA=""A=",nom_imageA);
GET_ARGUMENT_C("imageM=""M=",nom_imageM);
GET_ARGUMENT_C("imageT=""T=",nom_imageT);
/* Parametre introduit le 20220121141035... */
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
/* Le 20230823124532, a ete supprime : */
/* */
/* GET_ARGUMENT_P("seuil=""s=",seuil_de_limite_entre_l_interieur_et_l_exterieur); */
/* */
/* qui ne sert a rien et provient en fait, historiquement, de 'v $xci/contours.01$K', */
/* 'v $xci/contours.11$K' ou encore de 'v $xci/contours.12$K'... */
GET_ARGUMENT_L("complementer=""comp=",complementer_l_image);
/* Parametre introduit le 20231128092920... */
GET_ARGUMENT_P("marqueur_interieur_contours=""marqueur=""mic=",marqueur_d_interieur_de_contours);
/* Parametres introduits le 20190713132526... */
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);
/* Parametres introduits le 20170530150522... */
GET_ARGUMENT_L("utiliser_bord_majoritaire=""majoritaire="
,utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage
);
/* Parametre introduit le 20230823133343... */
GET_ARGUMENT_L("matrice_inertie=""inertie="
,utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage
);
GET_ARGUMENT_F("facteur_vecteur_propre=""fvp=",facteur_____vecteur_propre);
GET_ARGUMENT_F("translation_vecteur_propre=""tvp=",translation_vecteur_propre);
/* Parametres introduits le 20230825115100... */
GET_ARGUMENT_L("utiliser_niveau_maximal_point_isole=""point_isole="
,utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage
);
/* Parametre introduit le 20230827094130... */
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
);
/* Parametres completes par l'aleatoire le 20181225173548 et completes le 20231010093951... */
GET_ARGUMENT_I("methode=",gen_ft_____methode_standard);
/* Parametre introduit le 20231010115303... */
GET_ARGUMENT_L("est=""dc1=",parcours___est);
GET_ARGUMENT_L("nord=""dc2=",parcours__nord);
GET_ARGUMENT_L("ouest=""dc3=",parcours_ouest);
GET_ARGUMENT_L("sud=""dc4=",parcours___sud);
GET_ARGUMENT_L("nord___est=""dc12=",parcours__nord___est);
GET_ARGUMENT_L("nord_ouest=""dc23=",parcours__nord_ouest);
GET_ARGUMENT_L("sud_ouest=""dc34=",parcours___sud_ouest);
GET_ARGUMENT_L("sud___est=""dc41=",parcours___sud___est);
/* Les Directions Cardinales de type 'v $xiii/vecteurs$DEF Rappel.sur.les.orientations' */
/* ont ete introduites le 20231201093838 dans l'idee d'une extension tridimensionnelle... */
GET_ARGUMENT_L("avertir_couleurs=""avertir=",avertir_lorsqu_il_n_y_a_pas_assez_de_couleurs);
/* Parametres introduits le 20161101095640... */
GET_ARGUMENT_L("editer_informations=""informations="
,editer_les_informations_relatives_a_chaque_contour_rempli
);
/* Parametres introduits le 20230814113953... */
/* */
/* Jusqu'au 20231129101526, il y avait ici par erreur : */
/* */
/* "editer__informations=" */
/* */
/* qui a ete corrige a cette date... */
GET_ARGUMENT_L("editer_nombre_contours_remplis=""editer="
,editer_le_nombre_de_contours_remplis_et_l_increment_optimal
);
/* Parametres introduits le 20161101095640... */
GET_ARGUMENT_L("optimiser_increment=""optimiser=""oi=",optimiser_automatiquement_l_increment);
/* Parametres introduits le 20161114130029... */
GET_ARGUMENT_L("editer_centres_gravite=""editer_centre_gravite=""ecg="
,Iremplissage_____editer_le_centre_de_gravite
);
/* Parametres introduits le 20161105105948 et complete le 20161106091321 avec le pluriel... */
GET_ARGUMENT_L("editer_matrices_inertie=""editer_matrice_inertie=""emi="
,Iremplissage_____editer_la_matrice_d_inertie
);
/* Parametres introduits le 20230825102403... */
)
);
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
/* Test introduit le 20170530152733... */
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(choisir_le_niveau_de_remplissage_dans_une_image_de_texturage)
,I4OU(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage)
,IL_FAUT(utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
)
/* Test introduit le 20230823133343... */
Bblock
PRINT_ATTENTION("le remplissage avec une image de texturage l'emporte sur les autres methodes");
EGAL(utiliser_la_taille_des_contours_comme_niveau_de_remplissage,FAUX);
EGAL(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage,FAUX);
EGAL(utiliser_la_matrice_d_inertie_pour_definir_le_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_la_taille_des_contours_comme_niveau_de_remplissage)
,I3OU(IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage)
,IL_FAUT(utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
)
/* Test introduit le 20230823133343... */
Bblock
PRINT_ATTENTION("la taille des contours l'emporte sur les autres methodes");
EGAL(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage,FAUX);
EGAL(utiliser_la_matrice_d_inertie_pour_definir_le_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)
,IFOU(IL_FAUT(utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
)
/* Test introduit le 20230825115536... */
Bblock
PRINT_ATTENTION("la recherche du niveau majoritaire du bord l'emporte sur les autres methodes");
EGAL(utiliser_la_matrice_d_inertie_pour_definir_le_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_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage)
,IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage)
)
)
/* Test introduit le 20230827094130... */
Bblock
PRINT_ATTENTION("la recherche de la matrice d'inertie l'emporte 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
EGAL(choisir_le_niveau_de_remplissage_dans_une_image_de_texturage,FAUX);
/* Par defaut... */
Test(IFEQ_chaine(nom_imageT,NOM_PIPE))
/* Tout ceci fut introduit le 20220121141035... */
Bblock
CALi(Iinitialisation(ImageTexture,marqueur_d_interieur_de_contours));
/* Initialisation inutile, mais c'est quand meme plus propre... */
Eblock
ATes
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageTexture,nom_imageT))))
Bblock
EGAL(choisir_le_niveau_de_remplissage_dans_une_image_de_texturage,VRAI);
Eblock
ATes
Bblock
CALi(Iinitialisation(ImageTexture,marqueur_d_interieur_de_contours));
/* Initialisation inutile, mais c'est quand meme plus propre... */
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
Test(IFEQ_chaine(nom_imageM,NOM_PIPE))
/* Tout ceci fut introduit le 20161118100552... */
Bblock
CALi(Iinitialisation(ImageMarqueur,marqueur_d_interieur_de_contours));
Eblock
ATes
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageMarqueur,nom_imageM))))
Bblock
Eblock
ATes
Bblock
CALi(Iinitialisation(ImageMarqueur,marqueur_d_interieur_de_contours));
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageArgument,nom_imageA))))
Bblock
DEFV(Int,INIT(compteur_des_contours,ZERO));
/* Compteur des contours remplis introduit le 20161101094836. On notera que l'on ne connait */
/* pas a priori le nombre de contours a extraire... */
DEFV(pointF_2D,coin_inferieur_gauche);
/* Coin inferieur gauche de la zone de remplissage, */
DEFV(pointF_2D,coin_superieur_droite);
/* Coin superieur droite de la zone de remplissage. */
Test(IL_FAUT(complementer_l_image))
Bblock
CALS(Icomplementation(ImageContours,ImageArgument));
/* Possibilite introduite le 20231128092920... */
Eblock
ATes
Bblock
CALS(Imove(ImageContours,ImageArgument));
Eblock
ETes
INITIALISATION_POINT_2D(coin_inferieur_gauche,CADRE_GAUCHE,CADRE_INFERIEUR);
/* Definition du coin inferieur gauche de remplissage, */
INITIALISATION_POINT_2D(coin_superieur_droite,CADRE_DROITE,CADRE_SUPERIEUR);
/* 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))
/* Boucle introduite le 20161114130029... */
Bblock
CLIR(compteur_des_contours);
Test(EST_VRAI(le_niveau_de_remplissage_des_contours_est_aleatoire))
/* Test introduit le 20181225173548 et deplace ici le 20231121152154... */
Bblock
SPIRALE_VALIDATION;
INITIALISATION_POINT_2D(point_courant_de_l_espace_de_parametrage,FLOT(Xmin),FLOT(Ymin));
Test(IL_FAUT(compatibilite_20231121))
Bblock
Eblock
ATes
Bblock
DEFV(Float,INIT(niveau_initial_aleatoire_de_remplissage_des_contours,FLOT__UNDEF));
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
ETes
Eblock
ATes
Bblock
Eblock
ETes
EGAL(niveau_courant_de_remplissage_des_contours,FLOT(niveau_initial_de_remplissage_des_contours));
CALi(Inoir(ImageRemplissage));
CALi(Imove(ImageTemporaire1,ImageContours));
begin_image
Bblock
DEFV(genere_p,INIT(niveau_courant,load_point(ImageTemporaire1,X,Y)));
DEFV(genere_p,INIT(marqueur_courant,load_point(ImageMarqueur,X,Y)));
DEFV(pointF_2D,point_courant);
/* Point de depart de l'extraction de contour. */
Test(IFET(IFET(EST_VRAI(ITb1(fond,INDX(niveau_courant,NOIR)))
,EST_FAUX(ITb1(bord,INDX(niveau_courant,NOIR)))
)
,IFEQ(marqueur_courant,marqueur_d_interieur_de_contours)
)
)
/* Ainsi, on se place sur le premier point {X,Y} qui appartient au fond et qui est */
/* eventuellement marque... */
/* */
/* Le 20161118100552 a ete introduite la possibilite d'etre beaucoup plus selectif en */
/* n'etant plus exhaustif (via une image 'ImageMarqueur')... */
Bblock
DEFV(Float,INIT(prochain_niveau_courant_de_remplissage_des_contours,FLOT__UNDEF));
INITIALISATION_POINT_2D(point_courant,_____cNORMALISE_OX(X),_____cNORMALISE_OY(Y));
Test(IL_FAUT(choisir_le_niveau_de_remplissage_dans_une_image_de_texturage))
/* Possibilite introduite le 20220121141035... */
Bblock
EGAL(niveau_courant_de_remplissage_des_contours,load_point(ImageTexture,X,Y));
Eblock
ATes
Bblock
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
/* Possibilite introduite le 20170530150522... */
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
,Iremplissage_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);
/* Introduit le 20170601154435 car, en effet, ce seuillage manquait et faisait donc */
/* que le niveau de marquage "effectif" (apres le 'GENP(...)') pouvait etre egal a 'NOIR'. */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_le_niveau_majoritaire_au_bord_comme_niveau_de_remplissage))
/* Possibilite introduite le 20230823133343... */
Bblock
BSaveModifyVariable(Logical
,Iremplissage_____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
,Iremplissage_____calculer_l_histogramme_du__bord
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage))
/* Possibilite introduite le 20230825115536... */
Bblock
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
/* Calcul du centre de gravite... */
begin_nouveau_block
Bblock
BSaveModifyVariable(Logical
,Iremplissage_voisinage_____calculer_la_matrice_d_inertie_du__fond
,utiliser_la_matrice_d_inertie_pour_definir_le_niveau_de_remplissage
);
REMPLISSAGE_DU_CONTOUR_COURANT(niveau_courant_de_remplissage_des_contours);
/* Calcul de la matrice d'inertie... */
begin_nouveau_block
Bblock
DEFV(deltaF_2D,vecteur_propre_1);
DEFV(deltaF_2D,vecteur_propre_2);
/* Definition des deux vecteurs propres... */
Test(IFET(IZEQ(Ixy),IZEQ(Iyx)))
Bblock
INITIALISATION_ACCROISSEMENT_2D(vecteur_propre_1,FU,FZERO);
INITIALISATION_ACCROISSEMENT_2D(vecteur_propre_2,FZERO,FU);
/* On choisit arbitraiement la base {{1,0},{0,1}}... */
Eblock
ATes
Bblock
DEFV(Float,INIT(s1,FLOT__UNDEF));
DEFV(Float,INIT(s2,FLOT__UNDEF));
/* Definition des deux valeurs propres... */
EGAL(s1,RACINE_REELLE_p_DE_L_EQUATION_DU_SECOND_DEGRE(cA,cB,cC));
EGAL(s2,RACINE_REELLE_n_DE_L_EQUATION_DU_SECOND_DEGRE(cA,cB,cC));
/* Calcul des valeurs propres 's1' et 's2'... */
/* */
/* Soit 'M' la matrice d'inertie : */
/* */
/* | | */
/* | Ixx Ixy | */
/* M = | | */
/* | Iyx Iyy | */
/* | | */
/* */
/* ses valeurs propres s'obtiennent en resolvant l'equation : */
/* */
/* det(M - s.I) = 0 */
/* */
/* (ou 's' represente les valeurs propres) soit : */
/* */
/* (Ixx-s).(Iyy-s) - Ixy.Iyx = 0 */
/* */
/* ou encore : */
/* */
/* 2 */
/* s -(Ixx+Iyy).s + (Ixx.Iyy - Ixy.Iyx) = 0. */
/* */
/* Les vecteurs propres 'V' s'obtiennent en resolvant l'equation : */
/* */
/* M.V = s.I.V */
/* */
/* soit : */
/* */
/* Ixx.Vx + Ixy.Vy = s.Vx */
/* Iyx.Vx + Iyy.Vy = s.Vy */
/* */
/* d'ou : */
/* */
/* (Ixx-s).Vx + Ixy.Vy = 0 */
/* Iyx.Vx + (Iyy-s).Vy = 0 */
/* */
/* Le determinant de ce systeme etant nul, il y a indetermination ; on peut donc fixer */
/* arbitrairement l'une des deux composantes... */
INITIALISATION_ACCROISSEMENT_2D(vecteur_propre_1,FU,NEGA(DIVI(SOUS(Ixx,s1),Ixy)));
NORMALISATION_ACCROISSEMENT_2D(vecteur_propre_1);
/* Calcul du premier vecteur propre, en fixant arbitrairement a 1 la composante en 'X'. */
INITIALISATION_ACCROISSEMENT_2D(vecteur_propre_2,FU,NEGA(DIVI(SOUS(Ixx,s2),Ixy)));
NORMALISATION_ACCROISSEMENT_2D(vecteur_propre_2);
/* Calcul du deuxieme vecteur propre, en fixant arbitrairement a 1 la composante en 'X'. */
Eblock
ETes
EGAL(niveau_courant_de_remplissage_des_contours
,AXPB(facteur_____vecteur_propre
,Theta_2D(ASD1(vecteur_propre_1,dx),ASD1(vecteur_propre_1,dy))
,translation_vecteur_propre
)
);
/* Le niveau de remplissage est choisi en fonction de l'angle polaire de l'un des deux */
/* vecteurs propres... */
Test(IL_FAUT(Iremplissage_____editer_la_matrice_d_inertie))
/* Test introduit le 20230825172403... */
Bblock
CAL3(Prme2("VecteurPropre1={%+.^^^,%+.^^^}\n"
,ASD1(vecteur_propre_1,dx),ASD1(vecteur_propre_1,dy)
)
);
CAL3(Prme2("VecteurPropre2={%+.^^^,%+.^^^}\n"
,ASD1(vecteur_propre_2,dx),ASD1(vecteur_propre_2,dy)
)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_nouveau_block
ESaveModifyVariable(Logical
,Iremplissage_voisinage_____calculer_la_matrice_d_inertie_du__fond
);
Eblock
end_nouveau_block
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_le_niveau_maximal_d_un_point_isole_comme_niveau_de_remplissage))
/* Possibilite introduite le 20230827094130... */
Bblock
begin_nouveau_block
Bblock
BSaveModifyVariable(Logical
,Iremplissage_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(Iremplissage_voisinage_____niveau_maximal_d_un_point_isole,FLOT(NOIR_PLANCHER))
);
ESaveModifyVariable(Logical
,Iremplissage_voisinage_____rechercher_le_niveau_maximal_d_un_point_isole
);
Eblock
end_nouveau_block
Eblock
ATes
Bblock
Eblock
ETes
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))
/* Test introduit le 20230814113953... */
Bblock
CAL3(Prme1("NumeroContour=%d ",compteur_des_contours));
CAL3(Prme1("NombrePoints=%d ",Iremplissage_voisinage_____nombre_de_points_du__fond));
CAL3(Prme2("Niveau=%d (%f) "
,GENP(niveau_courant_de_remplissage_des_contours)
,niveau_courant_de_remplissage_des_contours
)
);
/* Edition introduite le 20230828150302... */
CAL3(Prme2("Point={%+.^^^,%+.^^^}",ASD1(point_courant,x),ASD1(point_courant,y)));
CAL3(Prme0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
CALS(Ior(ImageTemporaire1,ImageTemporaire1,ImageTemporaire2));
/* Ainsi, 'ImageTemporaire1' 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} du */
/* fond). */
CALS(Ior(ImageRemplissage,ImageRemplissage,ImageTemporaire2));
/* Cumul du remplissage courant en vue du Resultat... */
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
/* Test introduit le 20170530152733... */
Bblock
Eblock
ATes
Bblock
Test(EST_VRAI(le_niveau_de_remplissage_des_contours_est_aleatoire))
/* Test introduit le 20181225173548... */
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
)
);
/* Possibilite introduite le 20231010093951... */
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
(ImageTemporaire1
,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))
/* Test introduit le 20170530133136... */
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
,COND(IL_NE_FAUT_PAS(compatibilite_20180711)
,NEUT(niveau_initial_de_remplissage_des_contours)
,SUCN(niveau_initial_de_remplissage_des_contours)
)
);
/* A compter du 20161102113914, les niveaux sont geres "modulo"... */
Eblock
ATes
Bblock
Test(IL_FAUT(compatibilite_2023112810))
/* Test introduit le 20231128101918... */
Bblock
Eblock
ATes
Bblock
EGAL(prochain_niveau_courant_de_remplissage_des_contours
,niveau_initial_de_remplissage_des_contours
);
Eblock
ETes
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_image
Test(IL_FAUT(utiliser_la_taille_des_contours_comme_niveau_de_remplissage))
/* Test introduit le 20170530152733... */
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
Test(IL_FAUT(compatibilite_2023112811))
/* Test introduit le 20231128111230... */
Bblock
EGAL(increment_du_niveau_de_remplissage_des_contours
,DIVI(FLOT(PREN(COULEURS)),FLOT(compteur_des_contours))
);
Eblock
ATes
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)
)
);
Eblock
ETes
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))
/* Test introduit le 20170530152733... */
Bblock
Eblock
ATes
Bblock
Test(IZGT(compteur_des_contours))
/* Test introduit le 20220123123956... */
Bblock
Test(IL_FAUT(editer_le_nombre_de_contours_remplis_et_l_increment_optimal))
Bblock
CAL3(Prme1("NombreContoursRemplis=%d\n",compteur_des_contours));
/* Fonctionnalite introduite le 20161101095640... */
CAL3(Prme1("IncrementOptimal=%+.^^^\n",DIVI(FLOT(PREN(COULEURS)),FLOT(compteur_des_contours))));
/* Fonctionnalite introduite le 20161101100623... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ATTENTION("aucun contour n'a ete rempli");
Eblock
ETes
Eblock
ETes
CALi(Iupdate_image(nom_imageR,ImageRemplissage));
/* Memorisation du resultat. */
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
RETU_Commande;
Eblock
ECommande