diff --git a/Doc/image77.html b/Doc/image77.html
new file mode 100644
index 0000000..47b1127
--- /dev/null
+++ b/Doc/image77.html
@@ -0,0 +1,321 @@
+
+
+libimage: la doc de l'interface Fortran
+libimage et fortran
+dernière mise à jour: 26 juin 2022
+
+Le FORTRAN77 est définitivement perdu, du moins la version GNU
+n'est plus maintenue. Il est donc temps de passer au Fortran Moderne.
+
+
+
+Voici la description de l'interface de l'ancien système.
+Le couplage avec gfortran sera assez semblable.
+
+
+
+
+
+
+SLOT = IMG_CREATE(WIDTH, HEIGHT, 3)
+ Création d'une nouvelle image de type RGB en mémoire.
+
+ NEWSLOT = IMG_CLONE(SLOT)
+ Création d'une copie en mémoire d'une image existante.
+
+ CALL IMG_FREE(SLOT)
+ Destruction d'une image. Il est convenant de ne plus utiliser son
+ numéro de slot après cette opération.
+
+ CALL IMG_CLEAR(SLOT, RED, GREEN, BLUE)
+ Remplissage d'une image avec les valeurs RGB entre 0 et 255.
+
+ CALL IMG_DIMS(SLOT, WIDTH, HEIGHT)
+ Récupération des dimensions d'une image.
+
+
+
+
+
+Je vous préviens d'entrée, les problèmes de BOUTISME sont
+loin d'être réglés. Donc pour le moment, ça ne marche bien QUE sur
+des processeurs de type 386 .
+Pour les Sparcs c'est en bonne voie. A vous
+d'essayer, et de me raconter ça...
+
+
+
+
+PIC = TGA_ALOAD(NOM, W, H, T)
+ Chargement en mémoire de l'image 'NOM' et récupération de trois
+ de ses caractéristiques: largeur, hauteur et ???. La valeur retournée
+par la function est le numéro de slot, à conserver précieusement.
+
+ FOO = TGA_SAVE_N(SLOT, NUMBER)
+ Sauvegarde du SLOT au format TGA sous un nom de fichier de la forme
+im_nnnnn.tga . exemple: NUMBER=42 donne 'im_00042.tga' .
+ Le nombre de '0' de tête étant à vérifier,
+ utsl .
+
+
+ FOO = IMG_PPM_SA(SLOT, NOM, 0)
+ Enregistrement au format
+portable pixmap en mode ascii. Attention,
+ les fichiers sont très gros. Par contre, ils sont très facile à lire
+ sur toutes les plateformes. fonction pas trop testée .
+
+ FOO = IMG_TGA_SA(SLOT, NOM, 0)
+ Pareil, sauf que ça sauve en TGA 24 bits non compressé... Mais la
+compression est prévue. Attention, le nom de fichier ne doit pas contenir
+d'espaces.
+
+
+
+haut de page
+
+
+
+
+call img_version(flag) Affiche la version de la librairie sur stdout . Si le FLAG
+est différent de 0, infos supplémentaires.
+
+ call img_dumpslots(flag) Une liste des images actuellement déclarées. FLAG à 1 donne plus
+d'informations.
+
+
+haut de page
+
+
+Je ne vais pas m'étendre sur les effets disponibles. Il y a plus de docs
+ici où
+là . Je vais juste expliquer comment les
+ appeler depuis g77. Il y a deux façons de proceder: appels directs (kimarch)
+ et utilisation d'un interpréteur de commandes (kimarchePAS).
+
+
+
+Quelques effets expérimentaux sont arrivés en Janvier 2003. Le source de
+l'interface est img77x.c et vous trouverez dedans bien plus de
+détails que ce que je ne peux en donner ici.
+
+
+haut de page
+
+
+
+Attention, la rigueur mathématique de ces fonctions n 'est pas
+garantie. Avant de critiquer, Utsl .
+
+
+
+
+call img_grayrnd0(slot, bas, haut)
+call img_rgbrnd0(slot, bas, haut)
+call img_rgbrnd1(slot, br, bv, bb, hr, hv, hb)
+call img_grayrnd2(slot, bas, haut)
+
+
+
+
+Dans le fichier funcs77.f , vous trouverez une fonction de démonstration
+des générateurs de bruit.
+
+
+
+haut de page
+
+
+
+Attention, ces fonctions ne sont pas blindées, il y a de fortes probabilités
+de coredump si les paramètres passés sont incohérents.
+
+
+
+
+
+
+
+
+haut de page
+
+
+
+Là aussi c'est un peu brouillon, j'ai rajouté ça rapidement
+alors que je travaillais sur le
+recuit simulé .
+En fait, c'est un domaine assez vaste, et qui n'est pas trop normalisé dans
+les systèmes Unix. Donc, je bricole , et je ne
+construit rien de vraiment concret.
+
+
+
+Houba ? Hop !
+
+ call img_txt_0(numimg, texte, x, y, mode)
+ Le plus tortueux des paramètres, c'est mode , qui peut prendre
+plusieurs valeurs non documentées.
+
+
+
+haut de page
+
+
+
+POVray est un ray-tracer qui
+peut utiliser des height_fields , c'est à dire des matrices à deux
+dimensions dont chaque élément représente une
+altitude.
+
+
+
+img_hf_plot (img, x, y, h)
+ Ecriture de l'altitude d'un point. L'altitude est un entier compris
+ entre 0 et 32767. Le clipping est mal géré.
+ h = img_hf_height (img, x, y)
+ Lecture de l'altitude d'un point. Une valeur négative indique à coup
+ sûr une erreur.
+ img_hf_add (image, x, y, valeur)
+ Ajoute valeur à l'altitude du point x,y. L'altitude résultante sera
+ automagiquement bornée entre 0 et 32767.
+ img_hf_smooth(src, dst, k)
+ Lissage d'une image. K permet de régler la force de l'action, et
+ c'est expliqué là .
+ img_hf_noise3(img, coef, flag)
+ Bruitage d'une image, proportionnellement à l'altitude. Le coef
+ doit être un double precision . flag n'est pas utilisé, donc
+ il faut mettre 0.
+
+
+
+Pour sauvegarder un height-field généré depuis le Fortran, on utilisera
+les fonctions classiques d'enregistrement
+de fichiers Targa.
+
+
+haut de page
+
+
+
+
+call img_mix0(numsrc1, numsrc2, numdst, float_coef)
+ Mix of the two source pictures in the destination. The coefficient
+is a float between 0.0 and 1.0 but you can try others
+values...
+
+
+
+haut de page
+
+
+
+call img_cadre(numimage, type)
+
+type est un entier donnant le numéro du cadre. Pour ceux qui veulent
+une correspondance, il faut chercher dans img77a.c .
+
+
+haut de page
+
+
+
+Mmmmm... Pas de code Fortran écrit, mais déja un peu de
+documentation de quelques primitives en C.
+
+
+
+haut de page
+
+
+Certaines de ces choses devraient plutôt être vues comme
+ des fonctions . Ce n'est pas si simple.
+
+
+haut de page
+
+
+Mmmmm ...
+
+haut de page
+
+
+ Dans le tarball vous
+trouverez un demo77.f et un funcs.f qui pourront vous
+servir de base de départ. Mais pour voir tout de suite de quoi il
+s'agit :
+
+
+ PROGRAM exemple
+
+ INTEGER image, IMG_CREATE
+
+ image = IMG_CREATE(200, 200, 3)
+ CALL IMG_CLEAR(image, 127, 127, 127)
+ CALL IMG_NOISE(image, image, 242)
+ CALL TGA_SAVE_N(image, 42)
+
+ END
+
+
+
+Ici , vous trouverez un
+début de tutoriel sur la création des Hf par programme. Rien de spécifique
+au Fortran, mais des principes généraux ré-utilisables.
+
+
+haut de page
+
+
+
+Sur la plupart des systèmes libres, on utilise le compilateur
+ g77 . Et même sur des systèmes non
+ libres, d'ailleurs...
+
+On peut aussi écrire des
+ CGI avec g77.
+ Mais je n'ai pas encore testé une combinaison de cgi77 et libimage.
+
+Une alternative digne d'interet est PGPLOT pour dessiner
+ en Fortran. Votre g00gl3 favori
+ vous trouvera le lien kivabien.
+
+Je travaille de temps en temps sur quelques traitements de
+"haut niveau" en Fortran77, c'est un peu du
+code
+intérimaire, puisque une migration vers gfortran est en
+préparation.
+
+
+Depuis quelques jours, j'ai ouvert un
+blog pour vous
+raconter mon utilisation alternative de ce langage d'un autre
+siècle.
+
+
+
+
+
+
+
+
diff --git a/Doc/img-alpha.html b/Doc/img-alpha.html
new file mode 100644
index 0000000..b9fedb0
--- /dev/null
+++ b/Doc/img-alpha.html
@@ -0,0 +1,94 @@
+
+
+libimage: le canal alpha
+
+dernière mise à jour: 25 octobre 2013
+
+
+
+
+A vrai dire, je suis un peu désolé de vous proposer une page ouaibe
+dont le contenu est presque totalement absent. Il faut avouer que
+l'écriture de cette doc devient de plus en plus bordélique. Et je
+n'ose pas imaginer le foutoir que ça va être quand je vais vouloir
+faire une traduction en anglais :)
+
+
+
+Le deuxieme problême, et sûrement le plus grave, c'est que je n'ai jamais
+été fixé sur la signification d'un octet alpha : la valeur 255
+est-elle transparence absolue, ou pas de transparence du tout ?
+
+
+
+
+int Image_add_alpha_channel(Image_Desc *img, int value);
+ Rajoute un plan 'alpha' non initialisé a une image de type RGB. Retourne
+ le code d'erreur VERY_STRANGE si il y a
+ déja un canal alpha.
+
+ int Image_kill_alpha_channel(Image_Desc *img);
+ Détruit un éventuel canal 'alpha' ou retourne VERY_STRANGE en cas de
+ doute ou d'incertitude.
+
+
+ int Image_RGBA_over_RGB(Image_Desc *rgba, Image_Desc *src,
+ Image_Desc *dst);
+ Pour voir cette fonction en service, vous devez aller fouiller dans les
+ sources de Debian vs. eEmpire , plus précisement dans finisher.c .
+
+ int Image_alpha_op_0(Image_Desc *src, Image_Desc *dst, int v1, int v2,
+ int rb, int rt, int gb, int gt, int bb, int bt,
+ int param);
+ given two levels by RGB component, this func build an alpha
+ binary mask where pixels in the 3 RGB intervals have the v1
+ alpha value, and all others have the v2 alpha value. Image_alpha_reduce(Image_Desc *src, Image_Dest *dst, int yo);
+ Pour chaque pixel, les valeurs r, g et b sont mises à l'échelle par
+ la valeur alpha du pixel.
+
+ int Image_poke_alpha_from_rgb(Image_Desc *src, Image_Desc *dst,
+ int fr, int fg, int fb, int flag);
+
+
+
+
+
+Vous constaterez, à la lecture des lignes précédentes, que je ne sais
+pas encore bien gérer la transparence.
+
+
+
+haut de page
+
+
+TROLL : pour l'Alpha, le mieux, c'est
+DEC haut de page
+
+
+
+
+
diff --git a/Doc/img-asciiart.html b/Doc/img-asciiart.html
new file mode 100644
index 0000000..e1f7121
--- /dev/null
+++ b/Doc/img-asciiart.html
@@ -0,0 +1,70 @@
+
+
+libimage: AsciiArt p0w4
+libimage / AsciiArt p0w4
+dernière mise à jour: 4 novembre 2013
+
+
+
+
+Attention, ceci est un work in progress . L'interface de certaines
+fonctions n'est pas encore stabilisée. On peut même dire que ce n'est
+pas utilisable.
+
+
+
+Pour les curieux, il y a quand même un programme de test: t_ascii.c
+dans le tarball qui contient quelques
+informations. Il convient également de rappeler que les résultats que
+vous obtiendrez sont très dépendants de l'image d'origine.
+
+
+ascii Dans cette série de fonctions, nous allons voir des horreurs qui ne
+marchent pas très bien. En général, là , nous allons travailler sur des
+niveaux de gris et/ou de couleur. Et comme les trucs que je fait sont
+vraiment nuls, vous devriez plutôt essayer la libcaca du
+génial Sam .
+
+
+
+int Image_ascii_0(Image_Desc *src, char *fname, int largeur);
+
+ int Image_ascii_1(Image_Desc *src, char *nom, int width, char *cars);
+
+
+
+ascii art Dans cette série de fonctions, nous allons voir des horreurs qui ne
+marchent pas très bien. En général, là , nous allons travailler sur
+des contours, des images binaires.
+
+
+ int Image_asciiart_1(Image_Desc *src, char *pattern, int reverse);
+ Oups, mais cette fonction semble fonctionner :)& .o*O& qui va représenter les différents niveaux de gris.
+
+
+
+
+
+
diff --git a/Doc/img-bitplane.html b/Doc/img-bitplane.html
new file mode 100644
index 0000000..e256a85
--- /dev/null
+++ b/Doc/img-bitplane.html
@@ -0,0 +1,108 @@
+
+
+libimage: les plans de bits
+libimage: les plans de bits
+
+
+dernière mise à jour: 5 avril 2014
+
+
+Une image que j'appelle parfois bitplane , parfois plan de bits ,
+est une image binaire, c'est-à -dire que chaque pixel est représenté par un
+seul bit, qui ne peut prendre que deux valeurs: 0 ou 1. Pour chacune de ces
+deux valeurs, une teinte rgb8 est associée, et ces deux teintes seront
+utilisables par les routines de sauvegarde de ces images.
+
+
+Pour les curieu^geeks, voici (au 20 mars 2010) ce qu'est en gros un
+descripteur de bitplane, sous réserve de modifications puiqu'il faut
+considérer ça comme une structure opaque :
+
+
+typedef struct {
+ unsigned int magic;
+ int width, height; /* are negative allowed ? */
+ int id;
+ U_BYTE r0, g0, b0, r1, g1, b1;
+ char name[IMG_OBJNAME_LEN+2];
+ int tabname; /* explain this field, please */
+ unsigned long *plane;
+ int reserved;
+ } A_BitPlane;
+
+#define MAGIC_BIT_PLANE 0xb142ae17 /* XXX value not fixed */
+
+
+Il est possible qu'il existe des contraintes sur les dimensions
+ du bitplane. Utsl.
+
+
+haut de page
+
+
+La création sera simple : d'abord, on demande au truc un bitmap, et,
+si on en obtient un, on ajuste éventuellement les divers paramètres entrevus
+plus haut. Il peut y avoir des cas où le système refuse.
+
+
+
+
+A_BitPlane * Image_give_me_a_BP(int width, int height);
+ Demande la fourniture d'un bitplane dons les dimensions sont livrées.
+ Les autres réglages de celui-ci sont positionnés à des valeurs par défaut
+ (lesquelles valeurs sont de nature dddd ) cohérentes pour la suite
+ des opérations.
+
+ int Image_BP_setname(A_BitPlane *bp, char *name);
+ Attribue un nom (d'une longueur inférieure à IMG_OBJNAME_LEN )
+ à un bitplane. Ce nom pourra être éventuellement inscrit sur l'image
+ sauvegardée dans un fichier .
+
+
+
+haut de page
+
+
+
+int Image_BP_clear(A_BitPlane *bp, int bit);
+ Effacement, remise à bit d'une bitplane.
+
+ int Image_BP_plot(A_BitPlane *bp, int x, int y, int bit);
+ Positionnement d'un bit dans le bitplane. Attention, bit
+ doit avoir 0 ou 1 comme valeur.
+
+
+haut de page
+
+
+
+int Image_BP_savepcx(A_BitPlane *bp, char *filename, int flag);
+ Enregistrement en PCX monochrome. Ne fonctionne pas encore.
+
+
+ int Image_BP_to_pbm(A_BitPlane *bp, char *fname, int k);
+ Enregistrement en portable bit map non compressé. La relecture
+ est pour bientôt.
+
+
+haut de page
+Et ensuite ?
+
+
+Vous en savez assez maintenant. Vous pouvez expérimenter en attendant
+l'arrivée de l'interface Fortran .
+
+
+haut de page
+
+
+
diff --git a/Doc/img-cadres.html b/Doc/img-cadres.html
new file mode 100644
index 0000000..8c7fdb1
--- /dev/null
+++ b/Doc/img-cadres.html
@@ -0,0 +1,111 @@
+
+
+libimage: comment faire des cadres
+
+dernière mise à jour: 28 janvier 2014
+
+
+Bon, pas grand chose à dire, là sur le coup. La commande
+tga_cadre peut vous donner quelques
+explications pertinentes. Mais je vais quand même ajouter un petit message:
+Je voudrais bien qu'on m'envoie d'autres sources pour tracer des cadres,
+parce que je trouve que ça manque...
+
+
+
+
+
+
+int Image_cadre_A(Image_Desc *im);
+ Juste un cadre simple: un petit filet blanc autour de l'image.
+
+ int Image_cadre_cracra(Image_Desc *im, int largeur, int reserved);
+ Une sorte de machin bizarre, qui remplace l'ancienne fonction
+ Image_cadre_B . le troisième paramêtre n'est pas encore
+ utilisé. Voir aussi Image_cadre_U pour un truc aussi U gly int Image_cadre_C(Image_Desc *im, int r, int g, int b, int n);
+ En fonction de la distance n du bord de l'image, un dégradé entre
+ la teinte (r,g,b) et la valeur du pixel.
+
+ int Image_cadre_bruit(Image_Desc *im, int r, int g, int b, int n);
+ Proportionnellement à la distance n du bord de l'image, on choisit
+ randomatiquement un pixel de l'image ou un pixel(r,g,b). Il peut parfois
+ arriver qu'une couche randomatique supplémentaire de bruit soit rajoutée.
+
+ int Image_cadre_E(Image_Desc *im, int r, int g, int b, int dim);
+ Un cadre spécialement étudié pour
+ blablanux , donc en permanente mutation.
+
+ int Image_cadre_pattern_0(Image_Desc *im, Image_Desc *pat, int l);
+ ...
+
+ int Image_cadre_pattern_1(Image_Desc *im, Image_Desc *pat, int n);
+ ...
+
+ int Image_cadre_pattern_2(Image_Desc *im, Image_Desc *pat, int n);
+ ...
+
+ int Image_cadre2_pixx(Image_Desc *src, Image_Desc *dst, int p1, int p2);
+ C'est une sorte de cadre 'dendrite', mais assez discret. Avec un peu de
+fractalisation, on doit
+pouvoir faire beaucoup mieux. J'y travaille, mais c'est assez délicat Ã
+faire si on ne veut pas que ça dure des heures...
+
+ int Image_cadre_f(Image_Desc *im, int a, int b);
+ This func is a derivative of the _original_ cadre function
+named 'Image_cadre_A' and located in file 'cadres.c'
+
+ int Image_cadre_burp_0(Image_Desc *img, int p1, int p2, int gval);
+ Deux dégradés sur toute la largeur/hauteur de l'image. Les params
+p1 et p2 déterminent la largeur des bandes, en horizontal et
+en vertical, gval
+donnera l'intensité de la composante verte.
+
+ int Image_cadre_burp_2(Image_Desc *img, int sz, int pr, int pg, int pb);
+ Modifications chromatiques de largeur sz .
+
+ int Image_cadre_rasta_0(Image_Desc *img, int taille);
+ Première tentative de rastafarisation du cadre.
+ Le paramètre taille règle la largeur des bandes.
+
+ int Image_raz_sides(Image_Desc *im);
+ Hop, un petit détournement de fonction. Celle-ci met à 0 tous les
+ pixels du bord de l'image. Pour en savoir plus, il faut lire la doc sur les
+ filtres .
+
+
+
+
+
+En fait, il serait convénient que je fasse une
+page ouaibe
+avec quelques exemples de ces cadres.
+D'autre part, dans le kit d'outils associé à la libimage, il y a
+un programme qui encadre les images.
+
+
+
+
+
+
+
diff --git a/Doc/img-calculs.html b/Doc/img-calculs.html
new file mode 100644
index 0000000..71245f9
--- /dev/null
+++ b/Doc/img-calculs.html
@@ -0,0 +1,95 @@
+
+
+libimage: la doc des calculs !
+libimage / calculs
+dernière mise à jour: 14 octobre 2013
+
+
+
+
+Cette page décrit les "calculs" que l'on peut faire
+sur une image grace à la libimage .
+La frontière entre 'calculs' et
+'opérations ' est parfois assez floue...
+
+
+
+
+
+int Image_stats_zone_0(Image_Desc *img, Image_Rect *zone,
+ int *pmr, int *pmg, int *pmb,
+ int *pdr, int *pdg, int *pdb);
+ calcule sur une zone la moyenne et le delta max-min des composantes.
+Une prochaine version devrait aussi calculer un truc dans le genre de
+l'écart-type.
+
+ int Image_luminance(Image_Desc *s, Image_Desc *d, int f);
+ On multiplie la valeur des pixels par f/255 . Théoriquement,
+ ce f doit être entre 0 et 255. Je n'ai pas la moindre idée de
+ ce qui se passe avec des valeurs en dehors de ces limites. Il est hélas
+ aussi probable que cette fonction soit victime d'erreurs d'arrondi.
+
+ int Image_minmax_RGB(Image_Desc *img, int *res);
+ Calcul des extremums sur les 3 composantes de l'image.
+
+ int Image_histo_RGB(Image_Desc *im, long *hr, long *hg, long *hb);
+ Calcul des histogrammes sur les 3 composantes R, G et B. Les trois tables
+ doivent être déclarées: long hX[256]; et il devrait exister une
+ fonction pour les convertir en histogrammes cumulés.
+
+
+
+haut de page
+
+
+
+LUT est l'acronyme classique pour 'look-up table'.
+En français, on pourrait peut-être
+dire 'table de translation'. Dans notre cas, elles sont surtout utilisées
+pour associer une valeur numérique arbitraire à l'intensité d'une
+composante d'un pixel.
+
+
+
+
+int Image_calclut_lin(int *lut, int v0, int v255);
+ Création d'une table linéaire de 256 valeurs:
+lut[0]=v0 jusqu'Ã lut[255]=v255.
+
+
+
+
+D'autres calculs de LUT s sont en chantier, et sortiront
+au grand jour probablement en 2010 (ou 2013 ? (ou 2014 ?)).
+
+
+haut de page
+liens
+La rubrique des liens, toujours aussi vide. Mais bon, on le sait
+que c'est vide...
+Rattrapez vous ici
+
+
+
+
+
+
diff --git a/Doc/img-combine.html b/Doc/img-combine.html
new file mode 100644
index 0000000..cc03350
--- /dev/null
+++ b/Doc/img-combine.html
@@ -0,0 +1,123 @@
+
+
+libimage: combiner des images
+libimage / combiner des images
+dernière mise à jour: 27 septembre 2018
+
+
+
+
+
+
+int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ int sy, int oy, int zak);
+ ou Image_combine_columns(... XXX
+
+ int Image_combine_checker(Image_Desc *s1, Image_Desc *s2,r
+ Image_Desc *d, int sx, int sy, int ox, int oy, int zak);
+ Ben, ça fait un damier...
+
+ int Image_combine_random_point(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int yo);
+ On prend au (presque) hasard un point sur une des deux images. Le paramètre
+ yo peut varier entre 0 et 100.
+
+ int Image_combine_cercle_flou(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int yo);
+ Il manque des paramètres à cette fonction pour le positionnement
+ du cercle flou , son diamètre et son intensité.
+
+ int Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2,
+Image_Desc *d, int yo, int p1, int p2);
+ Tiens, aucun des 3 paramètres n'est utilisé ? Vraiment étrange.
+
+
+int
+Image_combine_minmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int flg);
+ Si flag est à 1, on utilise le maximum, sinon, on utilise le minimum, et
+ cela pour chacune des composantes.
+
+ int Image_mix(Image_Desc *a, Image_Desc *b, Image_Desc *c, int k);
+ Mélange les composantes rgb de deux images. Le coefficient va de 0 à 10000,
+ mais vous pouvez tenter d'autres valeurs.
+
+ int Image_mix_rgb(Image_Desc *a, Image_Desc *b, Image_Desc *c,
+ int kr, kg, kb);
+ Pareil, sauf qu'il y a un coefficient par composante.
+
+
+int
+Image_combine_4img_0( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *s3, Image_Desc *s4,
+ Image_Desc *dst);
+
+ Je ne sais pas ce que ça va faire.
+
+
+
+int Image_combine_Vdegrade(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int sens); Degradé horizontal ou vertical entre deux images.
+ Le paramètre 'sens' détermine quelle image sera à droite (en haut) du
+ résultat.
+
+
+int Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+
+
+En gros, si un pixel de s2 n'est pas complètement noir,
+il est recopié dans d . Sinon, on prend le pixel dans s1 .
+Une version de cette fonction avec les seuils paramétrables est
+en chantier. Vous pouvez aussi aller consulter la
+page sur le canal alpha.
+
+
+
+int Image_combine_power(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+
+Vous pouvez essayer d'échanger les deux images sources...
+
+
+
+int Image_combine_XOR(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+
+Vous pouvez aussi essayer d'échanger les deux images sources, mais ça
+ne marche pas très bien. Vous venez de comprendre.
+
+
+
+
+
+Naturellement, on arrive vite à inventer 42000 façons de combiner deux
+images. Dans ce domaine précis, j'aimerais avoir plus d'imagination.
+Hélas, ce n'est pas le cas...
+
+
+haut de page
+
+liens libimage: utilisation des couleurs
+libimage: les couleurs.
+dernière mise à jour: 12 janvier 2014
+
+
+
+
+
+
+int Image_couleur_moyenne(Image_Desc *im, int *pr, int *pg, int *pb);
+ Calcul de la valeur moyenne de chacune des composantes RGB sur toute la
+ surface de l'image.
+
+ int Image_colors_2_Map(Image_Desc *s, Image_Desc *d, RGB_map *m, int mode);
+ "remappe" l'image source en utilisant uniquement les couleurs
+ contenues dans la palette. Le paramètre mode peut prendre les
+ valeurs 0, 1, 2, 11, 12 ou 13. Une démonstration de ces remaps est
+ prévue .
+ Sauf que ça rame grave sa race !!!
+
+ int Image_to_gray(Image_Desc *s, Image_Desc *d, int flag);
+ Transforme une image couleur en image en niveau de gris. L'image
+ 'destination' est toujours une image RGB, seul le contenu est converti
+ en 'photo noir et blanc'. Le canal alpha ,
+ si il existe, n'est pas touché.
+Si le flag est à 0, on utilise les poids adéquats (r=297 v=589 g=114),
+sinon, les 3 composantes ont toutes le même poids.
+
+ int Image_to_gray_k(Image_Desc *s, Image_Desc *d, nt kr, int kg, int kb, int flag);
+ Identique à la fonction précédente, sauf qu'on peut spécifier les poids de
+ chacune des composantes. Attention aux dépassements de capacité, qui peuvent
+ néammoins devenir outils de création.
+
+ Image_color_shift_rgb(Image_Desc *s, Image_Desc *d, int r, int g, int b);
+ Rotation des 3 composantes couleurs.
+
+ int Image_apply_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
+ Bon, voyons, comment expliquer ça?
+
+ int Image_gray_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
+ Chaque pixel de l'image est d'abord converti en niveau de gris par
+ un calcul alambiqué, puis retraduit en couleurs en utilisant la palette
+ fournie.
+
+
+
+
+haut de page
+
+
+
+
+
+int Image_load_color_Map(char *file, char *name, RGB_map *where);
+ Les colors maps sont censees etre compatible avec celles de FRACTINT,
+ mais il faudrait verifier. En prime, je soupçonne un bug dans cette
+ fonction. Le nombre de couleurs lues est dans where->nbre , la
+ valeur retournée par la fonction est le code d'erreur.endroits .
+
+ int Image_save_color_Map(char *file, char *name, RGB_map *map);
+ Les colors maps sont censées etre compatible avec celles de FRACTINT,
+ mais il faudrait verifier. ymmv.
+
+
+ int Image_make_random_Map(char *nom, RGB_map *map, int nbre);
+ Remplissage de la palette &map avec nbre couleurs
+ aléatoires.
+
+ int Image_make_222_Map(char *nom, RGB_map *map, int noise);
+ Fabrique une palette de 64 couleurs.
+
+ int Image_palette_3sinus(char *nom, RGB_map *ou, double pars[8]);
+ ...
+
+ int Image_map2ppm(RGB_map *p, char *fname, char *comment);
+Exportation d'une palette de couleurs dans un format utilisable
+ par ppmquant , qui permet de réduire le nombre de couleurs
+ d'une image.
+
+
+
+Il existe un outil pour dessiner
+une de ces palettes de couleurs stockée dans un fichier.
+Lequel appelle une fonction qui doit
+être décrite ici .
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-dessin.html b/Doc/img-dessin.html
new file mode 100644
index 0000000..05771a8
--- /dev/null
+++ b/Doc/img-dessin.html
@@ -0,0 +1,62 @@
+
+
+libimage: comment dessiner ?
+libimage / les dessinateurs
+dernière mise à jour: 23 janvier 2014
+
+
+
+
+
+
+int
+Image_paint_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b);
+ peindre un rectangle est facile.
+
+ int
+Image_draw_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b);
+ dessiner les bords d'un rectangle, c'est kwol aussi.
+
+ int
+Image_draw_line(Image_Desc *i, int x1, int y1, int x2, int y2, RGBA *q);
+ Et les plus courageux d'entre vous peuvent aussi essayer de tirer
+un trait sur leur passé...
+
+
+
+Il serait bon de rappeler ce qu'est une
+ structure Image_Rect . C'est simple, Ã la limite du rudimentaire,
+ et probablement pas très stable, évolutions
+ en chemin.
+
+
+
+typedef struct {
+ int x, y;
+ int w, h;
+ long reserved;
+ } Image_Rect;
+
+
+
+haut de page
+
+
+[ tTh dessine ]
+
+
+
diff --git a/Doc/img-detect.html b/Doc/img-detect.html
new file mode 100644
index 0000000..27a4fbb
--- /dev/null
+++ b/Doc/img-detect.html
@@ -0,0 +1,67 @@
+
+
+libimage: les detecteurs
+libimage / les détecteurs
+dernière mise à jour: 21 janvier 2010
+
+
+
+
+
+
+int Image_seuil_RGB(Image_Desc *s, Image_Desc *d, int r, int g, int b);
+ Seuillage des trois composantes d'une image. Les pixels dans l'image de
+destination auront les valeurs 0 ou 255.
+
+ int Image_AutoSeuilRGB(Image_Desc *s, Image_Desc *d);
+ Seuillage avec recherche automatique de l'équi-partition : c'est à dire
+ que j'essaye d'avoir le même nombre de pixels des deux cotés de la force.
+ Cette fonction n'a jamais vraiment été testée. Ymmv.
+
+ int Image_AutoSeuilGray(Image_Desc *s, Image_Desc *d, int *ps);
+ Seuillage sur les niveaux de gris (calculés par la formule r+g+b ,
+ qui n'est probablement pas la meilleure), et ce, avec la même recherche de
+ l'équi-partition. L'image resultante est une image binaire en rgb. La valeur
+ retournée par *ps est le seuil calculé, compris entre 0 et 3x256,
+ soit 784 . Ymmv .
+
+
+
+int Image_detect_flat_gray(Image_Desc *src, Image_Desc *dst, int param, int r1);
+ Détection des zones où, sur un voisinage 3x3, l'ecart entre le maxi et le
+ mini du gris est inférieur à 'param'.
+
+ int Image_pix2ptl(Image_Desc *img, int seuil);
+Voilà donc une fonction faite pour torturer vraiment la capacité
+de votre machine à swapper... Et comme c'est un truc écrit à lc, le fichier
+résultat est nommé pixels.ptl et peut être très gros.
+
+
+
+haut de page
+
+vous pouvez me contacter:oulala@chez.com haut de page
+
+[ tTh détecte ]
+
+
+
diff --git a/Doc/img-devel.html b/Doc/img-devel.html
new file mode 100644
index 0000000..e267cb8
--- /dev/null
+++ b/Doc/img-devel.html
@@ -0,0 +1,280 @@
+
+
+libimage: les regles du programmeur
+dernière mise à jour: 3 janvier 2014
+
+
+
+
+
+
+La documentation n'étant jamais à jour, il faut parfois aller lire les sources
+pour comprendre (parfois) le pourquoi du comment. Moi même, je n'y arrive
+pas toujours. Cette page me sert d'aide mémoire, donc c'est tout en
+vrac ...
+
+
+
+On peut marquer une image.
+Il existe quelques macros pour abstraire
+certaines choses, mais ce n'est pas très fini.
+
+
+
+
+
+Il y en a probablement pas mal, mais dans l'ensemble, c'est assez stable.
+Peut-être quand même quelques petits 'memory leak' qui trainent dans des
+recoins obscurs... Exemple:
+
+
+ foo = Image_alloc(bla...);
+ Image_tripote(foo, bar);
+ Image_DeAllocate(foo);
+ free(foo); /* ne pas oublier ça... */
+
+
+A ce moment, les zones mémoires contenant les pixels de l'image sont rendues
+au gestionnaire de mémoire, mais l'en-tête du descripteur d'image est
+encore malloc-é . Il convient donc de rajouter un free(foo) .
+
+
+
+Xv n'affiche pas les TGA fabriqués par Libimage ?
+Le bug n'est pas dans libimage, mais dans Xv. D'après les spécifications
+du format TGA, on peut ajouter un commentaire dans le fichier. Or, Xv
+ne reconnait plus les TGA comme des TGA si ce commentaire est présent, ce
+qui est le cas par défaut dans la bib. Le workaround est simple:
+il faut ajouter Image_set_comment(img, ""); avant
+d'enregistrer le fichier afin d'enlever le commentaire.
+Je pense même qu'il y a un truc dans le Makefile.
+
+
+le flag 'modified' du descripteur d'image est mal géré.
+Oui, en effet, il n'est parfois pas positionné par les fonctions
+qui le devrait. Une revue complète de tout le code pour corriger
+ce souci est programmée pour 2012.
+
+
+Par contre, le fait que certaines fonctions ne semblent pas finies n'est
+pas un bug. C'est un 'undocumented feature'. Et qu'il manque la
+documentation, c'est le lazzy effect .
+
+
+
+
+
+
+Début 2007, j'ai découvert que le compilateur g77 était un
+produit en fin de vie, et que les Linux récents avaient de plus en plus
+tendance à préférer gfortran . Il est donc probable que
+l'interface actuelle soit mise à l'écart
+et remplacée par un équivalent plus moderne.
+
+
+
+
+
+Merci au généreur donateur d'une Sun U5 grace auquel j'ai enfin pu
+finaliser l'adaptation
+du machin à une autre architecture que le trop commun i386 sous Linux,
+en l'occurence un processeur UltraSparc , tournant sous OpenBSD 4.4 .
+Et ça a été plus facile que je ne le pensait, les soucis de boutisme ayant
+déja été réglés dans une vie antérieure. D'autre part, ça a été une bonne
+occasion de nettoyer le code d'un certain nombre de warnings assez génants.
+
+Je dois d'abord préciser que la fidèle machine sur laquelle je fabrique le
+kluge est une très vieille Debian (une SID d'il y a cinq ans, c'est dire
+si je suis un dino ),
+et que le Gcc est également *vieux* :
+gcc version 4.0.3 (Debian 4.0.3-1) . C'est un peu génant, mais
+pas plus que si j'avais un Unixware 1.x :) Donc, en avant...
+Voyons, dans un ordre approximatif, les problèmes que j'ai rencontré:
+
+
+
+
+alloca.h
+Sur la machine ancestrale citée plus haut, je suis obligé d'inclure
+ ce fichier si je veux utiliser la fonction alloca. Mais ce n'est pas
+ nécessaire dans O44/sparc64. Je n'ai pas (pour le moment) trouvé de
+ solution automatique. Il vous faut donc éditer à la mano le
+ Makefile vers la ligne 31 et commenter la ligne
+ CC_HACKS=-DNEED_ALLOCA_H .
+
+
+L'emplacement des .h
+Par flemme de chercher une autre solution, je les place systématiquement
+ dans /usr/local/include , et le Gcc de l'Open44 ne va pas les
+ chercher à cet endroit là .
+ Tip: export C_INCLUDE_PATH=/usr/local/include ~/.profile .
+
+L'emplacement des .a et .so
+ Même Gcc, même punition. Après quelques essais rapidement désastreux avec
+le ld.so.conf , une lecture plus attentive des manpages m'a conduit
+à une (presque) même solution:
+export LIBRARY_PATH=/usr/local/lib ~/.profile .
+
+
+
+
+Bon, j'ai gruiké ça rapidement un dimanche pluvieux, ça marche mais ça n'est
+peut-être pas orthodoxe. Je vais consulter les experts en fromages pour savoir
+si j'ai pris le bon chemin.
+
+
+
+
+À priori, il reste pas mal de choses à faire, surtout pour rendre les
+boucles X-Y plus cache-friendly . Les buffers contenants les images
+étant organisés en tableaux de lignes, il y a probablement quelques
+hit/mess à grapiller. D'un autre coté, pour le moment, juste
+ça marche...
+
+
+
+
+
+Bah, fatigué de devoir recopier mes fichiers .MAP de
+palette à droite et à gauche,
+j'ai ajouté une func qui cherche dans quelques endroits. Donc, j'essaye
+en série:
+
+
+
+ le répertoire courant.
+ le rep dans la variable $LIBIMAGE_PATH
+ le chemin hardcoded : $(DESTDIR)/share/libimage
+
+
+
+
+
+La première chose à faire (comme d'hab) c'est d'aller lire le Makefile.
+Vous y découvrirez quelques options à positionner selon vos gouts.
+Et un de ces jours, je vais passer au tandem infernal automake/autoconf,
+si jamais j'arrive à comprendre comment ça marche.
+
+
+
+En attendant, les variables à positionner pour l'install sont:
+
+
+
+DESTDIR : /usr/local
+HTML_DIR : /usr/local + le répertoire html recevra les pages
+ que vous êtes en train de lire.
+SHARED_FILES : $(DESTDIR)/share/libimage contiendra les fichiers
+ de fontes et les colors maps.
+
+
+
+A la compilation, on peut aussi utiliser quelques -DMACHIN=42
+pour modifier le comportement de la bib. En phase de mise au point de la
+bibliothèque, il est capital de détecter les conditions anormales: eg:
+plotter en dehors de l'image. Donc, avec un -DABORT=1 ,
+les conditions anormales génererons un COREDUMP analysable
+avec gdb, si vous n'avez pas oublié de régler votre ulimit -c
+Ã une valeur raisonnable.
+
+
+alloca.h oui, là , il y a un léger souci. je suis en ce moment
+en train de tenter d'installer ma libimage dans un OpenBSD, et je ne
+sais pas quoi faire pour les alloca . (2007-12-30) investigations
+en cours. Sans compter que le problème va se poser aussi avec NetBSD.
+
+
+
+
+
+Bien que tout ce fatras soit codé à la gruik, j'essaye d'introduire un peu
+de rigueur dans la chose. En particulier, certains noms de paramètres de
+fonctions vont être normalisés. Ce qui, en fait, ne sert à rien, parce
+que c'est le codeur qu'il faudrait normaliser.
+
+
+
+pr100 Seuil de probabilité pour un choix randomatique. Une valeur
+comprise entre 0 et 99. Exemple: le
+ bruitage des HFs.
+
+
+Les hackeurs trouveront dans le fichier imprime.c une fonction :
+Image_print_sizeof_structs , qui affiche les tailles des diverses
+structures utilisées par les rouages internes.
+
+
+
+
+
+Il faut regarder les #define dans tthimage.h et la fonction
+Image_err2str dans msglib.c .
+Je préfère ne rien mettre ici, parce que j'aurais la flemme de le mettre
+Ã jour quand il faudrait le faire... En particulier pour classer les codes
+d'erreur en fonction de leur gravité.
+
+
+
+
+
+Elles sont habilement dissimulées dans le fichier tthimage.h , mais
+je ne leur porte qu'une confiance limitée.
+
+
+
+
+
+Deux dumpeurs de pixels dans dumppix.c . Le premier affiche des
+trucs en hexadécimal, et le second en ascii. Ne m'en demandez pas plus,
+je ne suis au courant de rien. Heureusement, il y a un autre
+package qui contient quelques tools
+assez performants.
+
+
+haut de page
+
+
+
+
+Il manque plein de choses dans cette bibliothèque de fonctions, ou dans les
+outils qui tournent autour. En Octobre 2003, je suis en train de travailler
+sur un éditeur de fontes 16x24, mais il ne sortira que quand il sera prèt.
+Nous sommes le 1er janvier 2014, et ça n'a pas avancé d'un pas.
+
+
+
+
+
+
+
diff --git a/Doc/img-df3.html b/Doc/img-df3.html
new file mode 100644
index 0000000..6770391
--- /dev/null
+++ b/Doc/img-df3.html
@@ -0,0 +1,130 @@
+
+
+libimage: les df3 de povray
+libimage / les df3 de povray
+dernière mise à jour: 10 novembre 2013
+# et
+#
+
+
+
+
+
+
+The density_file pattern is a 3-D bitmap pattern that occupies a unit
+cube from location <0,0,0> to <1,1,1> The data file is a raw binary
+file format created for POV-Ray called df3 format. The syntax provides
+for the possibility of implementing other formats in the future. This
+pattern was originally created for use with halo or media but it may
+be used anywhere any pattern may be used.
+
+
+
+Bon, il faut avouer que le code actuel est totalement buggué, que son
+API est pitoyable, et que je n'y consacre pas autant
+d'énergie qu'il le faudrait. Vous pouvez quand même aller
+voir l'avancement des essais.
+
+
+
+Primitives
+
+
+C'est toujours en cours de mise au point. Les API ne sont
+pas encore figées.
+
+
+
+
+DensityF3Head * Image_df3_alloc(char *nom, int x, int y, int z, int b);
+ Création d'un objet de type DF3 . Les trois paramètres
+ x, y & z sont les dimensions, b est le nombre
+ prévu de bytes par cellule à l'enregistrement dans un fichier. Les
+ divers autres attributs sont initialisés à une valeur raisonnable.
+ Chaque cellule est stockée dans un double , avec 1.0 représentant
+ la valeur maximum.
+
+ int Image_df3_free(DensityF3Head *ptr);
+ Destruction féroce d'un objet de type DF3 . Si la valeur
+ de retour n'est pas nulle, c'est catastrophe.
+
+ int Image_df3_put(DensityF3Head *ptr, int x, int y, int z, double dv);
+Dépose une valeur dans le machin. Retourne INVALID_PARAM
+si les coordonnées xyz sont en dehors du cube. Devrait aussi retourner un
+errcode si la valeur est en dehors des valeurs légales.
+
+int Image_df3_get(DensityF3Head *ptr, int x, int y, int z, double *pdv);
+Lecture d'une valeur dans le machin. Si en dehors du cube,
+renvoie INVALID_PARAM .
+
+int Image_print_DF3head(DensityF3Head *h, char *txt, int flag);
+ Affichage (plus ou moins) en clair d'un descripteur de DF3. Si la
+ valeur de retour n'est pas nulle, c'est qu'un problême a peut-être
+ été détecté.
+
+ int Image_df3f_get_dims(char *fname, int dims[], int display);
+ Lecture des dimensions d'un fichier df3. L'argument dims
+doit être un int dims[3] . Si display est différent de
+zéro, des trucs seront affichés.
+
+ int Image_df3_export(DensityF3Head *ptr, char *fname, int nbbytes);
+Enregistrement des données dans un fichier. Si nbbytes est Ã
+zéro, c'est la valeur donnée à la création de la structure qui sera
+utilisée. Sinon, on donne 1, 2 ou 4.
+
+
+Essais divers
+
+Attention, Ã ce jour (2 mars 2008), ces fonctions ne travaillent
+que sur des fichiers à un octet [0..255] par cellule. On peut en
+fait les classer dans la catégorie bricolages divers pour
+se rassurer si elles ne fonctionnnent pas.
+
+
+
+
+int Image_df3_xper_0(Image_Desc *src, char * fname_df3, int k);
+ Tentative de fabrication d'un fichier DF3 Ã partir d'une image en RGB.
+ Le résultat n'est pas concluant, mais l'idée mérite d'être approfondie.
+
+ int Image_df3_plot_histo(char *fname_df3, char *nomtga, int flag);
+ Histogramme linéaire du contenu d'un fichier DF3. Utilité plus que
+ douteuse. Nous allons essayer da faire mieux.
+
+ int Image_df3f_2_txt(char *nomdf3, char *nomtxt);
+ Dump d'un fichier df3 dans un fichier texte, Ã priori parsable
+ par les outils Unix classiques.
+
+ int
+Image_df3f_2_povinc(char *nomdf3, char *nominc, char *nomobj, int k, double dv);
+C'est cette fonction qui est actuellement en cours de test dans cette
+page , et les résultats
+semblent prometteurs. Le paramètre k contrôle le type du machin
+qui va servir à matérialiser le contenu de la cellule. Pour le moment,
+il n'y a que la bouboule.
+
+
+
+Il existe d'autres fonctions pour traiter les types de données
+ qu'utilise POVray : les champs d'altitude pour
+ le moment.
+
+[ tTh cherche ]
+
+
+
diff --git a/Doc/img-dither.html b/Doc/img-dither.html
new file mode 100644
index 0000000..617494a
--- /dev/null
+++ b/Doc/img-dither.html
@@ -0,0 +1,82 @@
+
+
+libimage: les 'ditherings'
+
+dernière mise à jour: 23 octobre 2013
+
+
+Un truc important à prendre en compte: ces fonctions réduisent avec vigueur le
+nombre de couleurs dans une image. Souvent, pour chacune des composantes,
+on a deux valeurs: 0 et uh . Pour commencer, je conseille
+vivement de donner la valeur 255 Ã uh .
+
+
+
+
+
+
+
+int Image_dither_Bayer_0(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255.
+
+int Image_dither_crude(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255.int Image_dither_2x2(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255.
+
+int Image_dither_3x3_0(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255.
+
+int Image_dither_3x3_1(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255, mais d'autres valeurs
+ marchent bien aussi.
+
+int Image_dither_3x3_2(Image_Desc *s, Image_Desc *d, int uh);
+ cette fonction n'est pas encore codée, ni même imaginée.
+
+int Image_dither_seuil_random(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être, en général, mis à 255. Il est souvent bon d'ajuster
+le contraste de l'image source pour ajuster l'image destination.
+
+int Image_dither_simple_error(Image_Desc *s, Image_Desc *d, int uh);
+ uh doit être absolument mis à 255. Parce que la fonction
+ contient un bug sournois que je tente de trouver...
+
+
+
+haut de page
+
+
+
+
+Et pour sauvegarder une image après dithering ? A vrai dire, il n'y a
+rien de spécifique pour le moment. J'ai en projet l'écriture des fichiers
+Pcx en 16 couleurs qui semble adapté,
+mais ce n'est qu'un projet :( .
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-effets.html b/Doc/img-effets.html
new file mode 100644
index 0000000..38ba67e
--- /dev/null
+++ b/Doc/img-effets.html
@@ -0,0 +1,202 @@
+
+
+libimage: la doc des effets !
+libimage / effets
+dernière mise à jour: 14 décembre 2013
+
+
+
+
+Cette page décrit les "effets spéciaux" que l'on peut appliquer
+sur une image graçe à la libimage .
+Et je suis bien d'accord, il manque des exemples. Vous pouvez en
+générer rapidement quelque-uns, en faisant appel à une
+fonction de test . Ou plus simplement
+en utilisant
+l'outil
+approprié.
+
+
+
+
+int Image_water(Image_Desc *source, Image_Desc *but, int intensite)
+ déplace randomatiquement les pixels comme si de l'eau était tombé
+ sur une aquarelle. Attention, il semble y avoir un bug dans
+ cette fonction.
+
+ int Image_noise(Image_Desc *source, Image_Desc *but, int intensite)
+ Rajoute du bruit aléatoire absolu dans une image. Une intensité de 10
+ donne un effet moyen. Chaque composante est traitée séparément.
+
+ int Image_mirror(Image_Desc *src, Image_Desc *dst, int res)
+ retourne une image rgb[a] de droite à gauche, comme dans un miroir.
+
+ int Image_upside_down(Image_Desc *src, Image_Desc *dst, int res)
+ Renverse une image de haut en bas ou de droite à gauche. Il ne faut pas
+ mettre la même image en source et destination.
+
+ int Image_swap_lines(Image_Desc *src, Image_Desc * dst) Echange des lignes (colonnes) paires et impaires de l'image.
+ RGB uniquement hélas...
+
+
+
+haut de page
+
+
+
+int Image_sinwave_1(Image_Desc *source, Image_Desc * but, double table[6])
+ Déformation étrange d'une image. Je ne sais absolument pas ce que doit
+ contenir la table.
+
+ int Image_sinwave_2(Image_Desc *source, Image_Desc * but, double table[6])
+ Déformation étrange d'une image. Je ne sais absolument pas ce que doit
+ contenir la table.
+
+
+
+haut de page
+
+
+Dans cette section, il y a des effets plus ou moins pas trop finis.
+Certains d'entre eux ont été conçus pour mon (futur) logiciel de montage
+de vidéos povesques .
+Ensuite, quand ils seront fixés, peut-être je changerais leur nom,
+tout en gardant un alias dans le source effects3.c .
+
+
+
+int
+Image_effect_x_0(Image_Desc *src, Image_Desc *dst, int kr, int kg, int kb)
+Déja plus de 4 ans de mise au point, et c'est pas encore fini...
+
+int
+Image_effect_x_1(Image_Desc *src, Image_Desc *dst)
+Déja plus de 4 ans de mise au point, et c'est pas encore fini...
+
+
+int
+Image_effect_x_3(Image_Desc *src, Image_Desc *dst, int kx, int ky, char *comp)
+Déja plus de 4 ans de mise au point, et c'est pas encore fini...
+
+
+
+
+haut de page
+rgbmask
+C'est nouveau, ça vient de sortir. Le principe est simple: éliminer, sur
+des critères divers, une ou deux composantes RGB de l'image, en les
+remplaçant par une valeur constante.
+Hélas, ces effets ont un défaut: ils survivent très mal à la compression
+JPEG .
+
+
+
+int Image_rgbmask_H(Image_Desc *src, Image_Desc *dst, int gris);
+ Dans le sens horizontal...
+ int Image_rgbmask_V(Image_Desc *src, Image_Desc *dst, int gris);
+ Dans le sens vertival...
+ int Image_rgbmask_2(Image_Desc *src, Image_Desc *dst, int gris);
+ Bon, c'est pas mal, mais c'est quand même très dépendant des
+dimensions de l'image.
+ int Image_rgbmask_R(Image_Desc *src, Image_Desc *dst, int gris);
+ Ah, celle-là semble prometteuse. En jouant sur la pondération
+de l'aléa, on doit pouvoir obtenir quelques trucs sympas...
+
+
+haut de page
+colorize
+C'est nouveau, ça vient de sortir. Ce sont des expérimentations sur les
+relations entre la luminosité, la couleur, et surtout la percevance des
+gens face à une nouvelle vision du monde.
+
+
+
+int Image_BiColor_0(Image_Desc *src, Image_Desc *dst, int k)
+ Si c'est clair, ça devient sombre. Si c'est sombre, ça devient clair.
+ Vice-versa et réciproquement inclus. Le paramètre k ne sert Ã
+ rien et doit être mis à 0.
+
+
+
+Oh, bien entendu, ces tripotages de pixels ça n'est pas au niveau de la
+troiD de
+merde faite
+sous Linux , mais j'ai quand même
+dans l'idée d'appliquer ces trucs à des séquences vidéo ou
+des GIfs animées .
+
+
+haut de page
+Quelques essais
+La rubrique des trucs improbables, des tentatives avortées, des machins
+pas finis. Nous allons commencer par un vieux truc : l'utilisation de
+la récursion.
+
+
+
+int Image_call_recursion(Image_Desc *image, Image_Desc *dest, int param);
+ Euh, c'est une peu difficile d'expliquer ce que ça fait, mais il suffit
+ de savoir que certaines valeurs du paramètre sont meilleures que d'autres.
+
+
+
+Et des fonctions dans ce genre, il y en a d'autres. Par exemple, pour obtenir
+un effet assez peu similaire à la récursion, mais quand même, j'ai de la
+mosaique sous le coude.
+
+
+
+int Image_mosaic_simple(Image_Desc *src, Image_Desc *dst);
+ Comme le nom l'indique clairement, c'est un truc simple.
+ int Image_mosaic_0(Image_Desc *src, Image_Desc *dst, int sx, int sy, int flg);
+ Comme le montre clairement le prototype, il y a des paramètres.
+ sx et sy sont les dimensions des pavés (il parait qu'il faut
+ dire "tuiles" maintenant) que l'on va examiner et traiter. Quand Ã
+ flg , je pense qu'il ne sert à rien, et qu'il faut mettre 0.
+
+
+
+haut de page
+liens
+La classique rubrique des liens, toujours aussi vide.
+Rattrapez vous ici ou
+là .
+
+
+
+
+
+
diff --git a/Doc/img-essais.html b/Doc/img-essais.html
new file mode 100644
index 0000000..0cb2b0f
--- /dev/null
+++ b/Doc/img-essais.html
@@ -0,0 +1,82 @@
+
+
+libimage: les essais
+
+dernière mise à jour: 20 janvier 2010
+
+
+
+
+Vu la mauvaise qualité de la documentation, il est parfois difficile
+de comprendre à quoi sert une fonction précise. Il y a donc une collection
+de fonctions permettant d'essayer à peu près simplement quelques trucs.
+C'est essais.c archive .
+En théorie, il y a des explications dans essais.h UTSL .
+
+
+
+
+int Test_rgbmask(char *srcname);
+ En chantier actuellement.
+
+ void Test_des_patterns(char *prefix, int foo, int bar);
+ La page décrivant les patterns ne contenant
+ que du texte, il me semble bien que vous puissiez en générer par vous même.
+ le paramètre prefix vous permet de préciser le chemin vers les
+ images générées, par exemple "/tmp/pattern" vous donnera
+ des noms de fichiers du genre /tmp/pattern_042.tga .
+
+ void Test_Egalisations(char *nomsource);
+ Essai des égalisations .
+ Image résultante: aaaa_egal.tga dans le
+ répertoire de travail. A gauche l'image originale, au milieu, l'algo
+ RGB , et à droite l'algo mono_0 .
+
+ void Test_Dithering(char *nomsource);
+ Essais des tramages .
+ On passe en revue: dither_Bayer_0 , dither_seuil_random
+ dither_simple_error et dither_double_seuil .
+ L'image d'origine est tout d'abord réduite de moitié, puis les
+ nombreux résultats sont collés dans une
+ image unique .
+
+ void Test_Effects_A(char *nomsource, int flag);
+ Démonstration de quelques effets .
+ L'image source est réduite de moitié. Le flag doit être (pour le
+ moment) mis à zéro.
+
+
+
+
+Comme expliqué je ne sais plus où, certaines de ces fonctions sont
+susceptibles d'écrire dans le répertoire courant des fichiers
+divers et variés dont le nom commencera par aaaa .
+Vous avez été prévenus. D'autre part, dans
+l'archive des
+outils , il y a plein de
+scripts shell pour essayer plein de trucs.
+
+
+
+haut de page
+
+
+
diff --git a/Doc/img-fichiers.html b/Doc/img-fichiers.html
new file mode 100644
index 0000000..546aa4b
--- /dev/null
+++ b/Doc/img-fichiers.html
@@ -0,0 +1,262 @@
+
+
+libimage: le(s) format(s) de fichier
+
+dernière mise à jour: 19 mars 2010
+
+
+Cette page décrit les différents formats de fichier que sait gérer
+la libimage .
+Le format de fichier originel de cette bibliothèque est le
+.TGA 24 bits non compressé. Les autres ont été rajoutés par la
+suite, et ne sont pas aussi testés que l'originel. D'autre part, c'est
+dans ces fonctions que le problème du BOUTISME est le
+plus flagrant: en gros vous risquez le coredump sur autre chose qu'un i386.
+
+
+
+
+
+
+
+
+
+
+int Image_TGA_save(char *filename, Image_Desc *img, int compress);
+ Le paramètre compress doit actuellement être à 0. Fonction
+qui ne semble plus victime de boutisme. Par contre, il manque toujours
+la compression.
+
+ int
+Image_TGA_save_component(char *nom, Image_Desc *img, char channel, int comp);
+ La composante channel ('r', 'g' ou 'b') sera sauvée sous la
+ forme d'un tga monochrome avec une palette.
+ Et il manque aussi la compression.
+
+ Image_Desc * Image_TGA_alloc_load(char *nom);
+ ...... En gros, ça prend un fichier .TGA sur le disque, et ça le met
+ dans une image, allouée à la volée. Les images compressées ne sont pas
+traitées, hélas.
+En détail, utsl .
+
+
+
+haut de page
+
+
+
+Image_BMP_save_24(char *filename, Image_Desc *img, int flag);
+ Sauvegarde d'une image au format BMP 24 bits non compressé (au fait,
+ça se compresse un bmp ?). En théorie, cette fonction est exempte des
+problèmes de boutisme. Hélas, un bug persistant fait que ça ne marche
+pas très bien.
+
+ int Image_BMP_infos(char *nom, int *pw, int *ph, int *pt, int verb);
+ Récupère, et éventuellement affiche (si verb!=0) quelques informations
+pertinentes sur un fichier bmp. Le retour *pt contient le nombre
+de bits par pixel.
+
+ Image_Desc * Image_BMP_alloc_load(char *nom, int reserved);
+ Allocation et chargement d'une image bmp. Actuellement (décembre 2003)
+seul quelques types sont mal supportés. Les autres ne le sont pas du
+tout.
+
+
+Bien évidement, la mauvaise qualité de la gestion de ce format est
+la conséquence de la flemme de tTh . Si vous voulez voir ça de
+plus près, il y a un testbmp.c dans le tarball.
+
+haut de page
+
+
+
+En cours... dithering .
+bitplanes .
+
+
+
+int Image_PCX_fileinfo(char *nom);
+ Affiche toutes les informations que l'on envisage de
+ trouver dans le header d'un fichier PCX.
+
+ int Image_wrPCX_8colors(char *nom, Image_Desc *im);
+ Euh, comment dire ?... Ça ne marche probablement pas.
+
+
+Bien évidement, la mauvaise qualité de la gestion de ce format est
+la conséquence de la flemme de tTh . Si vous voulez voir ça de
+plus près, il y a un testpcx.c dans le tarball.
+
+haut de page
+
+
+Ce format, totalement ouvert, est une survivance du passé.
+Pour tout dire, ça remonte à l'Amstrad PC1512 ! Il permettait
+de stocker une image en niveau de gris de façon rudimentaire, mais simple
+et facile à lire. Chaque pixel est codé sur un octet non signé.
+
+
+En-tête: +--------+
+ | WIDTH | largeur sur 16 bits à -la-Intel
+ +--------+
+ | HEIGHT | hauteur (idem)
+ +--------+------+
+ | pppppppppp... | première ligne de pixels
+ | pppppppppp... | deuxième...
+ et ainsi de suite jusqu'Ã la fin de l'image
+
+
+C'est donc un format 'monochrome', et on ne peut y mettre qu'une
+composante RGB, ou un canal alpha, ou n'importe quoi qui se code sur 8 bits.
+Vraiment rudimentaire, mais efficace
+sur un Amstrad PC 1512 :)
+
+
+
+int Image_PHT_save_component(char *name, Image_Desc *i, char col);
+ 'name' est le nom du fichier, l'extension .pht est recommandée.
+
+
+
+
+haut de page
+
+
+
+PNM est l'acronyme de Portable Net Map . Ce format est utilisé
+pour la communication entre une foultitude d'utilitaires de conversion
+de fichier images. Vous trouverez facilement de la doc dans
+le grand Ternet .
+
+
+
+
+int Image_wr_pbm_0(char *nom, Image_Desc *im, char channel);
+ Sauvegarde d'une image monochrome, le seuil étant à 128.
+ Le paramètre 'channel' est R,G,B ou A.
+ int Image_wr_ppm_0(char *nom, Image_Desc *im, int mode);
+ En théorie, le paramètre mode mis à 1 demande l'écriture d'un fichier
+ binaire, plus petit, mais moins portable. En pratique, mode doit être
+ mis à zéro, et on obtient un fichier ascii, qui peut être très gros.
+ int Image_wr_pgm_0(char *nom, Image_Desc *im, char channel);
+ Ecriture d'un fichier en niveau de gris du canal spécifié.
+
+
+
+
+Vous pouvez aussi regarder les HF
+pour une autre utilisation de ce format PNM.
+
+
+haut de page
+
+
+FITS est un format utilisé en astronomie. Pour le moment, j'en suis à la
+recherche de documentation. Pour en savoir un peu plus, allez fouiller dans
+Eclipse et revenez me faire part
+de vos découvertes.
+
+haut de page
+
+
+
+A la demande générale, j'ai rajouté un hack bien crade pour sauvegarder
+une
+image en jpeg. Mais il faut avoir l'utilitaire cjpeg sur votre système.
+
+
+
+int Image_system_cjpeg(Image_Desc *img, char *fname, int quality);
+ img est une image RGB en mémoire qui va être convertie en Jpeg sous
+le nom fname avec un facteur de qualité compris entre 0 et 100.
+Il suffira de taper man cjpeg au prompt de votre
+shell favori pour en apprendre plus.
+
+
+
+Attention, c'est vraiment un kludge, et ça risque de ne pas marcher à tous
+les coups...
+
+
+haut de page
+
+
+
+C'est nouveau, ça vient de sortir (enfin, il y a 8 ans que ce n'est
+pas fini ).
+Et pour le moment, comme ça ne marche pas trop bien, ça ne sert à rien.
+En bref, ce sont des listes de points (x,y,h,v) qui seront
+destinées à nourrir un programme fortran qui
+fabriquera des height fields .
+
+
+Pour être honnête, je n'ai pas la moindre idée de l'endroit où se
+trouve ce fameux programme fortran. Pas grave, j'en ferais un autre.
+
+
+
+haut de page
+
+
+
+Le but premier est de construire des images utilisables par LaTeX ,
+par exemple pour la version imprimée des
+Sources de Tar .
+La seconde étape sera de les utiliser dans des logiciels de PAO plus,
+ahem, institutionnels...
+
+
+haut de page
+
+
+
+L'habituelle rubrique des liens:wotsit décrit pleins
+de formats de toutes sortes de fichiers. Il existe aussi un
+utilitaire d'exportation
+reprenant certains des formats décrits ici.
+D'autre part, Image Magick
+est une bonne solution à tous ces problèmes de formats de fichier
+pour les images.
+
+
+
+
+
+
diff --git a/Doc/img-filtres.html b/Doc/img-filtres.html
new file mode 100644
index 0000000..5665102
--- /dev/null
+++ b/Doc/img-filtres.html
@@ -0,0 +1,93 @@
+
+
+libimage: les filtrages
+libimage / les filtrages
+dernière mise à jour: 28 novembre 2013
+
+
+
+
+Les filtres de base sont définis par un tableau de 11 entiers.
+Les 9 premiers représentent la matrice 3x3, le 10ème est le diviseur, et le
+11ème est l'offset ajouté à la fin du calcul. Il y a une fonction qui permet
+d'afficher ces valeurs. On trouvera également des filtres classiques
+appelables directement.
+
+
+
+filtres
+
+int Image_convolueur3(Image_Desc *in, Image_Desc *out, int *mat);
+ Je ne sais pas si le nom 'convolueur' est bien adapté...
+
+ int Image_lissage_3x3(Image_Desc *in, Image_Desc *out);
+ Moyennage des pixels sur la matrice 3x3.
+
+ void Image_filtre_display(FILE *ou, int *mat);
+ Affichage des valeurs d'un filtre. ou précise à quel endroit
+ l'envoyer. Vous pouvez utiliser stdout , stderr
+ ou un fichier que vous avez préalablement ouvert.
+
+ int
+Image_filtre_random(Image_Desc *src, Image_Desc *dst, int p1, int p2);
+ Les 9 coefficients du filtre sont choisis au hasard entre p1 et p2.
+N'oubliez pas d'appeller srand(getpid()) si vous obtenez la même
+chose à chaque course :-)
+
+ int Image_filtre_passe_bas(Image_Desc *in, Image_Desc *out);
+ parfois, il m'arrive de me demander si ce filtre n'est pas équivalent
+ au lissage 3x3...
+
+ int Image_filtre_passe_haut(Image_Desc *in, Image_Desc *out);
+ euh...
+
+ int Image_filtre_Prewitt(Image_Desc *src, Image_Desc *dst, int rotation);
+ C'est un filtre directionnel, et le paramètre rotation permet
+de le faire tourner.
+
+ int Image_filtre_Sobel(Image_Desc *src, Image_Desc *dst, int rotation);
+ C'est un filtre directionnel, et le paramètre rotation permet
+de le faire tourner.
+
+
+
+Certaines primitives du module 'filtres.c' necessitent une lecture
+approfondie du code source. ymmv.
+
+
+haut de page
+liens
+Comme d'habitude, utilisez votre g00gl3
+favori, et tentez des mots-clefs du genre 'convolution' ou 'sobel filter'.
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-marquage.html b/Doc/img-marquage.html
new file mode 100644
index 0000000..1dd07bc
--- /dev/null
+++ b/Doc/img-marquage.html
@@ -0,0 +1,98 @@
+
+
+libimage: marquer une image
+
+dernière mise à jour: 13 octobre 2013
+# et
+#
+
+
+
+
+
+Marquer une image
+
+
+Parfois, on a besoin de marquer, pour diverses raisons
+(parfois (et même souvent) idiotes),
+une image. Voici donc quelques fonctions sommaires permettant de faire ça.
+
+
+
+
+int Image_marque_0(Image_Desc *img, int val);
+
+Trace les deux diagonales de l'image avec un gris de niveau val .
+
+
+int Image_marque_1(Image_Desc *img, char *texte, int flags);
+ Place un 'label' dans le coin en haut à gauche de l'image.
+ Les flags ne sont pas utilisés pour le moment.
+
+int
+Image_marque_timestamp(Image_Desc *img, char *texte, RGBA *rgba);
+
+Inscrit la date et l'heure dans l'image, avec un petit message.
+Le papier est blanc, mais vous pouvez choisir la couleur de l'encre.
+
+
+
+int Image_grille(Image_Desc *im, int stx, int ox, int sty, int oy, RGBA *ink) ;
+ La grille peut être habilement centrée en utilisant les offsets
+ox et oy . Hélas, la composante alpha de l'encre
+n'est pas prise en compte...
+
+
+
+
+haut de page
+Marquer un rectangle
+
+D'autres fois, ce n'est qu'une zone particulière d'une image que l'on
+souhaite marquer. Actuellement, on ne peut agir que sur des zones
+particulières : des
+Image_Rect
+
+
+int Image_gadrct_cross(Image_Desc *img, Image_Rect *rect, int k);
+ Tracé d'une croix en diagonale dans la zone délimitée par rect .
+Le paramêtre k permettra de choisir différentes couleurs pour le fond
+et la croix.
+
+
+
+haut de page
+Fonctions connexes
+
+
+Maintenant, si vous voulez construire quelques images de référence,
+vous pouvez essayer les quelques mires
+disponibles.
+
+
+haut de page
+
+
+
+
+
+
diff --git a/Doc/img-mires.html b/Doc/img-mires.html
new file mode 100644
index 0000000..4842e43
--- /dev/null
+++ b/Doc/img-mires.html
@@ -0,0 +1,69 @@
+
+
+libimage: fabriquer une mire
+
+dernière mise à jour: 7 novembre 2013
+
+
+
+Les primitives
+
+
+int Image_mirRGB_0(Image_Desc *dst, int flag);
+ L'image de destination doit être en 256x256. Le flag doit être
+ à zéro.
+
+
+The more advanced
+
+
+
+int Image_mircol_0(Image_Desc *dst, char *txt, int flag);
+ Taille de l'image: 512x512. Le texte est optionnel. Le flag
+ doit être à 0.
+
+ int Image_mircol_1(Image_Desc *dst, char *txt, int flag);
+ Taille de l'image: 512x512. Le texte est optionnel. Le flag
+ doit être à 0.
+
+ int Image_mircol_2(Image_Desc *dst, char *txt, int mode);
+ Ceci est une tentative secrète pour mettre dans une image de dimensions
+données des choses que vous n'avez vraiment pas besoin de connaitre.
+
+ int Image_mircol_3(Image_Desc *dst, char *txt, int mode);
+ Ceci est une tentative pour mettre dans une image de dimensions
+données le maximum de teintes différentes, tout en ayant des dégradés
+harmonieux. C'est pas simple.
+
+ int Image_decompose(Image_Desc *src, Image_Desc *dst, int flag);
+ Une fonction un peu particulière.
+ Elle décompose, après réduction de taille, l'image source en ses trois
+composantes R, G et B.
+
+
+
+Avec un peu de chance, le verso
+de cette documentation est plus avancée. Il décrit un outil en cli
+permettant de créer des .tga de ces mires diverses.
+
+
+
+
+
+
diff --git a/Doc/img-op2x2.html b/Doc/img-op2x2.html
new file mode 100644
index 0000000..ddf207a
--- /dev/null
+++ b/Doc/img-op2x2.html
@@ -0,0 +1,62 @@
+
+
+libimage: les blocs 2x2
+
+dernière mise à jour: 12 novembre 2013
+
+
+
+
+
+
+
+int Image_2x2_contours_0(Image_Desc *im);
+ Une opération mythique, pour moi. Mais pas vraiment facile à comprendre.
+D'autant plus que cette fonction est un essai approximatif.
+
+ int Image_2x2_contours_1(Image_Desc *src, Image_Desc *dst);
+ La suite de l'opération mythique. En entrée c'est uniquement le bit
+7 de la composante R qui est utilisé, et en sortie, c'est uniquement
+le plan rouge qui est significatif.
+
+ int Image_2x2_contrast(Image_Desc *src, Image_Desc *dst);
+ Alors, c'est un truc qui semble détecter les contrastes locaux, dans une
+ matrice 2x2, mais je ne comprends pas trop comment.
+
+ int Image_2x2_lissage(Image_Desc *src, Image_Desc *dst);
+ Moyenne du voisinage [0..1][0..1] des pixels de l'image.
+ Voir aussi les filtres .
+
+ int Image_2x2_rot4pix(Image_Desc *src, Image_Desc *dst, int rot);
+ Rotulazionne de la imagines. A essayer, parce que moi, j'ai pas osé.
+
+
+
+
+Pour ces fonctions qui travaillent sur des matrices 2x2,
+il faut faire attention à l'éventuel déplacement de l'image du à une
+disymétrie par rapport au pixel de référence.
+
+
+
+
+
+
diff --git a/Doc/img-operat.html b/Doc/img-operat.html
new file mode 100644
index 0000000..d7d7a7b
--- /dev/null
+++ b/Doc/img-operat.html
@@ -0,0 +1,67 @@
+
+
+libimage: les operations
+
+dernière mise à jour: 27 janvier 2014
+
+
+
+
+fonctions
+
+
+
+int Image_egalise_RGB(Image_Desc *src, Image_Desc *dst, int yo);
+ Ajustationnement des niveaux d'une image par la méthode des histogrammes
+ cumulés. le parametre 'yo' n'est pas utilise actuellement.
+
+
+ int Image_egalise_mono_0(Image_Desc *src, Image_Desc *dst, int yo);
+ Ajustements des niveaux. L'histograme cumulé est calculé sur les niveaux
+de gris de l'image. Le paramètre 'yo' doir être égal à 0.
+
+ int Image_clear_component(Image_Desc *img, char component, int value);
+ Efface une des composante RGB à la valeur donnée.
+
+ int Image_operator(Image_Desc *in, char op, int val, Image_Desc *out);
+ Bon, c'est la fonction qui fait tout.
+Sauf le café.
+Les operateurs sont définis par un caractere: '+', '-', '>' ...
+La fonction retourne BAD_OPERATOR si l'opérateur n'est pas connu, et
+se contente alors de recopier la source dans la destination.
+
+
+
+haut de page
+
+
+
+Bah, euh... Il y a bien les outils pour
+quelques exemples d'utilisation.
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-patterns.html b/Doc/img-patterns.html
new file mode 100644
index 0000000..eb58af5
--- /dev/null
+++ b/Doc/img-patterns.html
@@ -0,0 +1,134 @@
+
+
+libimage: les patterns
+
+dernière mise à jour: 12 janvier 2012
+
+
+
+
+Pour le moment, le mieux à faire, c'est de
+'utsl ' et de
+tester .
+
+
+
+int Image_pattern_000(Image_Desc *img, int foo);
+ Ah, ça ne fait que du noir ?
+
+ int Image_pattern_001(Image_Desc *img, int foo);
+ gni ?
+
+ int Image_pattern_002(Image_Desc *img, int foo);
+ gni ?
+
+ int Image_pattern_003(Image_Desc *img, int foo);
+ C'est simple, le code n'est pas écrit.
+
+ int Image_pattern_004(Image_Desc *img, int a, int b, int c, int d);
+ C'est simple, le code n'est pas écrit.
+
+ int Image_pattern_005(Image_Desc *img, RGB_map *map);
+ gni ?
+
+ int Image_pattern_042(Image_Desc *img, RGB_map *map);
+ Ah, la réponse à la question universelle ssur la vie, l'univers et
+ le reste...
+
+ int Image_mirRGB_0(Image_Desc *dst);
+ gni ?
+ int Image_pattern_104(Image_Desc *dst, int sx, int sy, RGBA *a, RGBA *b);
+ Construction d'un damier.
+
+
+
+
+
+
+Une interface fortran est en préparation
+et devrait être disponible fin Février 2038. D'autre part, dans le
+fichier essais.c page d'exemples
+ est en préparation.
+
+
+haut de page
+
+
+
+int Image_fill_pat_0(Image_Desc *img, Image_Desc *pat, int centered);
+ Attention aux...
+ int Image_fill_pat_1(Image_Desc *img, Image_Desc *pat, int centered);
+ ...coredumps !
+
+
+haut de page
+
+
+
+Remplissage d'images avec des bruits divers. Que les statisticiens me
+pardonnent, mais ce que j'ai fait là est un peu empirique.
+Disons que pour le moment, ça me permet de faire ce que je veux.
+
+
+
+
+int Image_gray_noise_0(Image_Desc *dst, int low, int high);
+ Gris uniforme, valeurs comprises entre low et high.
+
+ int Image_rgb_noise_0(Image_Desc *dst, int low, int high);
+ RGB uniforme, valeurs comprises entre low et high.
+
+ int Image_rgba_noise_0(Image_Desc *dst, int low, int high);
+ RGB et alpha uniforme, valeurs comprises entre low et high.
+
+ int Image_rgb_noise_1(Image_Desc *dst, RGBA *low, RGBA *high);
+ Bruit uniforme avec des bornes inférieures et supérieures sur chacune
+ des composantes.
+
+ int Image_gray_noise_2(Image_Desc *dst, int low, int high);
+ Algorithme du lancement de dés pour obtenir une courbe en cloche.
+Mais la cloche ressemble à un pic :)
+
+ int Image_rgb_noise_2(Image_Desc *dst, RGBA *low, RGBA *high);
+ même galère pour faire la doc.
+
+
+
+haut de page
+
+
+
+Bah, euh...
+Ben non, ya presque rien.
+
+
+haut de page
+
+
+
+
+
+
diff --git a/Doc/img-plotters.html b/Doc/img-plotters.html
new file mode 100644
index 0000000..9be934c
--- /dev/null
+++ b/Doc/img-plotters.html
@@ -0,0 +1,80 @@
+
+
+libimage: les machines à plotter
+
+dernière mise à jour : 4 novembre 2013
+
+
+
+
+Sortie, sous forme graphique, de diverses données gérés par la librairie.
+Des histogrammes, des COLORMAP ...
+
+
+
+
+
+En règle générale, ces fonctions génèrent des fichiers au format Targa.
+
+
+
+int Image_plot_histo(char *nomtga, long *hr, long *hg, long *hb, char *txt);
+ L'image a une taille de 400x300. Pour calculer l'histogramme, il faut
+voir la fonction adéquate.
+
+ int Image_calc_plot_histo(Image_Desc *img, char *tganame);
+ Calcul et tracé de l'histogramme. Le texte affiché sera le nom de
+ l'image résultante, ce qui (à mha) est une grossière erreur.
+
+ int Image_plot_Map(char *nomtga, RGB_map *map , char *txt);
+ Dessine une palette de couleurs
+ de type Fractint . Attention aux textes
+ trop longs.
+
+ int
+Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte);
+ dessin d'une Look-Up Table. L'image a une taille de 400x300. Le texte
+ a une longueur maximum d'environ quelques caractères. Il est important de
+ ne pas confondre une LUT et une Palette.
+
+
+
+haut de page
+
+Fonction avancées
+
+
+Avancées, alors que ça semble plutôt être des primitives destinés Ã
+tracer dans une image déja existante...
+
+
+
+int Image_plot_h_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int h);
+ Fabrique dans une image une petite bande horizontale à partir d'une
+palette.
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-povhf15.html b/Doc/img-povhf15.html
new file mode 100644
index 0000000..963e1bb
--- /dev/null
+++ b/Doc/img-povhf15.html
@@ -0,0 +1,253 @@
+
+
+libimage: les height_fields de POVray
+libimage / les height_fields de POVray
+dernière mise à jour: 16 octobre 2013
+# et
+#
+
+
+
+
+
+
+Pour savoir ce qu'est un height_field , consultez le site de
+POVray , et fouillez la doc.
+Vous pouvez aussi en
+regarder un
+pour vous faire une idée...
+
+
+
+En fait, un height_field est un "champ d'altitude", une
+sorte de matrice à deux dimensions dont chaque cellule représente une hauteur.
+Cette hauteur est un nombre codé sur 15 bits, donc entre 0 et 32767.
+Les gens de POVray ont choisi, entre
+autres solutions, de stocker cette altitude dans des images .TGA en mettant
+les 7 bits de poids fort dans le canal rouge et les 8 bits de poids
+faible dans le canal vert.
+
+
+fonctions de base
+int Image_hf15_plot(Image_Desc *im, int x, int y, int h);
+ Place un point de hauteur h (entre 0 et 32768) aux coordonnées
+x et y. Les valeurs de h hors intervalle seront bornées.
+
+ int Image_hf15_height(Image_Desc *img, int x, int y);
+ Lecture de la hauteur du point aux coordonnées x et y. Cette hauteur est
+automatiquement limitée à l'intervalle autorisé.
+
+ int Image_hf15_hf2gray(Image_Desc *src, Image_Desc *dst, int mode);
+ Conversion d'un height_field en une image en niveaux de gris. Le paramètre
+mode n'est pas utilisé et doit être égal à 0.
+
+
+ int Image_hf15_rgb2hf(Image_Desc *src, Image_Desc *dst, int mode);
+ Conversion d'une image RGB en height_field. Le paramètre mode
+n'est pas utilisé. On doit le mettre à 0. Cette fonction va probablement
+évoluer dans un proche (ou lointain) avenir.
+
+ int Image_hf15_save_PGM(char *nom, Image_Desc *img, char *comment);
+ Sauvegarde un height_field en format
+PGM ascii. Le suffixe recommandé
+étant .pgm , mais vous faites comme vous voulez...
+Bien que le fichier soit
+conforme aux spécifications du PGM, Povray n'arrive pas à le lire.
+Ce bug devrait être corrigé dans la version 3.x qui est actuellement
+disponible, mais je n'ai pas encore testé.
+
+
+
+haut de page
+traitements
+
+int
+Image_hf15_lissage(Image_Desc *s, Image_Desc *d, int coef, int flag);
+ Lissage d'un height_field. Le paramètre coef représente le
+poids du point central de la matrice 3x3. Les huit autres points ont
+un coefficient de 1, ce qui n'est peut-être pas idéal.
+
+
+ int
+ Image_hf15_calc_minmax(Image_Desc *img, char *txt, int *pmin, int *pmax);
+ Calcul des extrèmes d'un height_field. Si txt!=NULL , un message
+est affiché. Si pmin et/ou pmax sont à NULL , le
+résultat correspondant n'est pas retourné. ah ah, no more segfault !
+
+ int
+Image_hf15_normalize(Image_Desc *src, Image_Desc *dst, int min, int max);
+ Ajustement linéaire d'un height-field afin que toutes les valeurs
+soient comprises entre min et max .
+
+ int
+Image_hf15_mul_add(Image_Desc *src, Image_Desc *dst, int mul, int add);
+ A tester plus en détails...
+
+ int Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef);
+ Dilatation d'un HF: chaque point est remplacé par le point le plus haut
+ de son voisinage 3x3. Cela a pour effet d'amplifier les sommets.
+ Le paramètre coef n'est pas utilisé, il est bon de mettre 1, pour
+ rester compatible avec les évolutions en projet...
+
+ int Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef);
+ Opération inverse de la dilation: amplification des vallées. coef
+n'est pas utilisé, mettre 1.
+
+ int Image_hf15_mult_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
+ Multiplication de deux height-fields, avec remise à l'échelle pour ne
+ pas faire de dépassements. Pas trop testé ;(
+
+ int Image_hf15_sqrt(Image_Desc *src, Image_Desc *dst);
+ Racine carré normalisée de l'altitude normalisée. Peu testée, mais
+ visuellement prometteuse.
+
+ int
+Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double p0w44)
+ En quelque sorte la fonction complémentaire de la racine carré. Et là aussi
+ on opère sur des valeurs normalisées.
+
+
+
+haut de page
+mixages
+Bien entendu, quand on commence à faire des height-fields, on se demande
+si on peut les combiner, les mélanger entre eux, faire du hfmix...
+Et effectivement, c'est possible. Il y a même un
+début de démonstration
+qui donne parfois de bonnes idées bien mouvantes.
+
+
+
+
+int
+Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int k);
+ Mélange de deux HF. Le coefficient k va de 0 à 10000, mais rien
+ ne vous empèche d'essayer d'autres valeurs. En principe, les débordements
+ sont correctement gérés.
+
+ int
+Image_hf15_mult(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
+
+Multiplication de deux hf15. Il risque d'y avoir des problèmes de dépassement
+de capacité dans cette fonction. Si cela vous arrive, il faut me faire
+signe .
+
+ int Image_hf15_getmin(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+ Recopie dans l'image de destination de la valeur minimale des deux
+ points correspondants dans les images s1 et s2. Il existe aussi la
+ fonction Image_hf15_getmax dont la sémantique est évidente.
+
+
+
+haut de page
+bruitages
+
+int Image_hf15_noise_0(Image_Desc *dst, int hi, int lo, int pr100);
+ Avec une probabilité de (pr100 % 100) , l'altitude sera mise entre
+hi et lo pour tout les points de l'image.
+
+ int Image_hf15_noise_1(Image_Desc *dst, int mo, int of, int pr100);
+ Cette fonction déplace une atltitude de 'mo' avec un offset de 'of'.
+ Le paramètre 'pr100' n'est pas utilisé.
+
+ int Image_hf15_noise_2(Image_Desc *dst, int pr100, int di, int k1, int k2);
+ Remplacement aléatoire du point courant par un de ses proches voisins.
+ Le code n'est hélas pas encore vraiment optimisé.
+
+ int Image_hf15_noise_3(Image_Desc *dst, double coef, int flag);
+ Léger bruitage proportionnel à la hauteur du point concerné. Cette fonction
+ a été inventée pour la montagne de
+ Sonia .
+
+
+
+Synthèses
+Nous pouvons également songer à fabriquer des height-fields à partir de
+calculs divers et plus ou moins abscons. Actuellement, il y a deux fonctions
+à peu près opérationnelles, mais pas encore figées.
+
+
+
+
+int Image_hf15_synth_0(Image_Desc *dst, Image_PtList *ptl);
+ Pas très fini, en cours de démoulage. Et vous ne savez pas ce qu'est
+ une PtList ? Voici un petit topo .
+ int Image_hf15_synth_fromfunc0(Image_Desc *dst, int k,
+ double(*func)(int x, int y, int k))
+ Vous avez sous la main une fonction du genre h = func(x, y) ?
+ Vous souhaitez la transformer en height-field ? No souçaï. Vous écrivez votre
+ fonction, vous créez une image des dimensions voulues, et vous utilisez
+ ce générateur magique, quoique pas encore fini. Son principal avantage est
+ de recadrer les valeurs fournies par votre fonction dans la dynamique
+ complète du hf.
+
+
+
+
+haut de page
+liens
+Il existe une interface G77 pour
+ ces fonctions.
+ POVray , and have a look at the new
+ 3.5 version...
+Pov Monde les POVeurs francophones.
+tTh fait quelques raytracings.
+Comment faire des images en relief .
+ un début de howto pour faire
+ des images avec les hf15s.
+ Il y a d'autres choses étranges dans POV: les
+df3 (aka density files) en font partie.
+
+
+
+
+Dans un autre domaine povesque , si vous créez deux images en déplaçant
+légerement le point de vue, vous pouvez les
+combiner en une image, que vous verrez en
+relief avec une paire de lunettes munie des
+filtres adéquats.
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-ptlist.html b/Doc/img-ptlist.html
new file mode 100644
index 0000000..3fbb853
--- /dev/null
+++ b/Doc/img-ptlist.html
@@ -0,0 +1,104 @@
+
+
+libimage: les listes de points
+libimage: les listes de points
+
+
+dernière mise à jour: 15 octobre 2013
+
+L'origine de ce concept se perd dans la nuit des temps, probablement
+aux alentours de 1998... Je n'ai pas le moindre souvenir de pourquoi j'ai
+commencé à imaginer ça. Mais il y a déja un peu de code écrit, autant
+que ça serve à quelque chose. Commençons par les concepts de base.
+
+
+Un point et une liste de points, c'est quoi ?
+
+
+Comme un point se réfère à une image, il va forcément avoir les
+coordonnées d'un pixel, donc un tuple x,y . Ensuite, nous avons
+deux attributs: le premier est assimilable à la "hauteur" de
+ce point dans le champ virtuel du monde pixelisé, et le second
+est laissé à l'imagination du codeur (pourquoi pas un index dans une
+LUT de couleurs ?) qui veut utiliser le kluge.
+
+Pour des raisons historiques d'occupation mémoire, toutes ces coordonnées sont
+stockées sur 16 bits. Désolé.
+
+
+
+typedef struct
+ {
+ short x, y; /* pixel position */
+ short h; /* pixel value */
+ short c; /* color index ? */
+ } Image_Point;
+
+
+
+Ensuite, pour manipuler des ensembles de points, nous les regrouperons dans
+des listes de, justement, points. A priori, le descripteur d'une liste de
+points n'est pas une structure publique, du moins, tant qu'elle n'est
+pas à peu près figée.
+
+
+Fonctions de bases
+
+
+
+
+Image_PtList * Image_ptl_alloc(int nbre, char *name);
+ Allocation d'une liste de points. nbre étant le nombre
+de points initialement alloués et name un texte arbitraire
+d'une taille limitée. La taille est dynamique, c'est à dire qu'une liste
+de points peut grossir à la demande.
+
+ int Image_ptl_kill(Image_PtList *ptl, char *msg);
+ Destruction d'une liste et probable récupération de la mémoire
+utilisée. Si NULL != msg , un message est éventuellement
+affiché sur stderr.
+
+ int Image_ptl_get_size(Image_PtList *ptl, int *nbre, int *alloc);
+ Récupère le nombre de points effectif dans la liste, et la place
+disponible actuelle. On peut passer NULL si on ne veut pas
+récupérer une des valeurs.
+
+ int Image_ptl_add(Image_PtList *ptl, int x, int y, int h, int c);
+ Ajout d'un point à une liste, en augmentant éventuellement la
+taille de celle-ci, la taille de la liste étant limité par la mémoire
+disponible, au bon vouloir du OOMK farceur. Il n'est
+actuellement pas possible d'enlever un point de la liste.
+
+ int Image_ptl_get(Image_PtList *ptl, Image_Point *pt, int idx);
+ Lecture d'un point depuis une liste. Coredumpe peut-être,
+mais pas trop souvent.
+
+ int Image_ptl_boundingbox(Image_PtList *ptl, Image_Rect *box);
+ Calcul de la boite qui englobe en x/y tous les points d'une liste.
+Il traine probablement une off-by-one erreur dans le code.
+Utilisez Image_dump_rect pour afficher
+le résultat.
+
+
+
+
+
+On peut, bien entendu, mettre ces listes de points dans des
+fichiers .
+
+
+
+
+haut de page
+
+
+
diff --git a/Doc/img-showdiff.html b/Doc/img-showdiff.html
new file mode 100644
index 0000000..1f49724
--- /dev/null
+++ b/Doc/img-showdiff.html
@@ -0,0 +1,94 @@
+
+
+libimage: montrer les differences
+libimage / montrer les différences
+dernière mise à jour: 20 janvier 2014
+
+
+
+
+Ces fonctions permettront de mettre en évidence les différences entre
+deux images (par exemple: avant et après un filtrage) mais sont toujours
+en cours de mise au point. Ceci dit, on peut aussi les classer dans
+les combinations d'images.
+
+
+
+
+
+int Image_showdiff_0(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst)
+ Pour chacune des composantes, la valeur est calculée ainsi:
+ v = ((v1 - v2)/2) + 127 .
+
+ int
+Image_showdiff_1(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst, int dmin)
+ Completement binaire sur les trois composantes. En pseudo-code, ça donne
+ à peu près ceci:
+
+ for component in (r, g, b)
+ if component(im1)>component(im2)
+ then pix=component.255
+ else pix=component.0
+ end for
+
+
+ int
+Image_showdiff_2(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst, int dmin)
+ cette fonction n'est pas vraiment finie...
+
+
+ int
+Image_showdiff_3(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst,
+ int kr, int kg, int kb)
+ Algo:
+
+ pour chaque composante
+ si delta(im1.C, im2.C) < kC
+ dst.C = 96
+ sinon
+ dst.C = 255
+
+
+
+
+
+Il existe plein d'autres façons de comparer deux images, et
+je vous laisse le soin de les imaginer...
+
+
+haut de page
+liens
+L'habituelle rubrique des liens, toujours complètement vide.
+Rattrapez vous ici ou
+là .
+
+
+
+vous pouvez me contacter:oulala@chez.com haut de page
+
+tTh is the king of diff
+
+
+
diff --git a/Doc/img-stereo.html b/Doc/img-stereo.html
new file mode 100644
index 0000000..1342bd0
--- /dev/null
+++ b/Doc/img-stereo.html
@@ -0,0 +1,95 @@
+
+
+libimage: la stéréo
+
+dernière mise à jour: 20 octobre 2013
+
+
+
+
+
+Le principe est simple: Avec POV , vous génerez deux images,
+une pour chaque oeil du spectateur, et vous combinez ces deux images
+en utilisant le rouge pour l'oeil droit et le vert pour l'oeil gauche.
+En regardant l'image résultante avec les lunettes kivonbien, vous verrez
+l'image en relief dans l'écran de votre dinateur.
+
+
+
+En pratique, c'est un peu plus délicat... C'est pas simple de trouver les
+bons angles de vue. J'ai rédigé un petit
+HOWTO
+
+
+Voyons maintenant les fonctions qui existent...
+
+
+int Image_combine_stereo_0(Image_Desc *gauche, Image_Desc *droite,
+ Image_Desc *stereo);
+ La fonction de base. Les deux images sources sont converties en gris
+ sans la moindre pondération, et l'image destination est faite en
+ utilisant les canaux rouge et vert.
+
+ int Image_combine_stereo_1(Image_Desc *gauche, Image_Desc *droite,
+ Image_Desc *stereo, int kr, int kg, int kb);
+ La fonction un peu plus évoluée.
+Les deux images sources sont converties en gris
+ avec trois podérations, et l'image destination est faite en
+ utilisant les canaux rouge et bleu.
+
+
+
+
+
+haut de page
+
+
+
+Ou trouver les filtres kivonbien pour se confectionner les lunettes ?
+A vrai dire, je ne sais pas encore. J'ai eu les miennes dans un
+"repas enfant" du McDo. A vous de trouvez les votres...
+
+
+haut de page
+
+
+
+Bah, euh... Avec un peu de chance, vous trouverez un exemple
+dans ça , mais ce ne
+sera peut-être pas très clair.
+Une explication un peu plus
+détaillée
+a été écrite en anglais de cuisine.
+Il existe aussi quelques fonctions
+pour traiter les height fields
+de Povray. Et d'autres méthodes de
+combinaisons d'images
+là .
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/img-television.html b/Doc/img-television.html
new file mode 100644
index 0000000..a9a930e
--- /dev/null
+++ b/Doc/img-television.html
@@ -0,0 +1,78 @@
+
+
+libimage: effets television
+libimage / effets télévision
+dernière mise à jour: 27 janvier 2014
+
+
+Voici quelques autres effets
+plus ou moins destinés à simuler ce que l'on pouvait voir
+dans l'ancien temps sur les écrans cathodiques de nos
+bonnes vieilles télévisions du temps de Guy Lux et Léon Zitrone.
+
+
+
+
+int
+Image_TV_grink(Image_Desc *src, Image_Desc *dst, int yo);
+ ?
+
+ int
+Image_TV_grok(Image_Desc *src, Image_Desc *dst, int yo);
+ ?
+
+ int
+Image_TV_gruud(Image_Desc *src, Image_Desc *dst, int yo);
+ Pour le moment, le paramètre ne sert à rien et doit être mis à 0.
+
+ int
+Image_TV_griiiz(Image_Desc *src, Image_Desc *dst, int yo);
+ Encore un truc sorti d'on ne sait où, et qui fait n'importe quoi.
+Le paramètre ne sert à rien et doit être mis à 0.
+
+ int
+Image_TV_veryold(Image_Desc *src, Image_Desc *dst, int p1, int p2, int p3);
+ Je ne sais pas à quoi servent les paramètres, mais ils ne doivent
+ pas être trop petits.
+
+ int
+Image_TV_pix_0(Image_Desc *src, Image_Desc *dst, int w, int h, int grey);
+ Pixelisation rectangulaire (w * h) avec un fond 'grey' entres les
+gros pixels.
+
+
+int Image_TV_cplus_proto(Image_Desc *src, Image_Desc *dst, int p);
+ Première tentative (novembre 2013) d'une simulation de la
+première chaine de télévision cryptée française. Le paramètre joue
+sur la taille du décalage des lignes.
+
+
+
+
+Pour essayer d'y voir plus clair dans mes simulations d'écran de
+vieilles télévisions, il y a une page de
+démonstration
+utilisant l'outil adéquat.
+Tout pour me donner l'envie d'aller plus loin dans ce domaine.
+
+
+haut de page
+
+
+
+
+
+
diff --git a/Doc/img-texte.html b/Doc/img-texte.html
new file mode 100644
index 0000000..778c85b
--- /dev/null
+++ b/Doc/img-texte.html
@@ -0,0 +1,221 @@
+
+
+libimage: les textes
+libimage / les textes
+dernière mise à jour: 14 décembre 2015
+
+
+
+
+
+
+Pas grand chose pour le moment...
+Juste quelques fonctions instables et un
+kludge permettant de tester ces fonctions. J'en arrive à me demander
+si la doc f77 n'est pas plus complète.
+
+
+Attention !!! Le 26 mars 2008, il y a eu un gros chargement dans
+la logique interne du bouzin: il faut maintenant soit spécifier un nom
+de fonte quand on trace une chaine, soit charger préalablement une fonte
+si on ne spécifie pas de nom. J'espère que ce changement ne va pas
+casser trop de trucs. Hélas, espoir déçu, j'ai un bronx infernal dans
+plein de trucs...
+
+
+Dans le tarball, il y a deux fontes 8x8 nommée libimage.fonte
+et 8x8thin .
+A priori, les fontes 8x8 prévues pour la console Linux doivent fonctionner,
+et vous pourrez les reconnaitre à leur taille de 2048 octets.
+Il n'y a pas encore de quoi les visualiser dans tout ce fatras,
+mais je suis en train de coder ça...
+
+
+
+int Image_load_fnt8x8(char *nomfnt, U_BYTE *ou, int flags);
+ Chargement d'une fonte 8x8 dans une zone statique, on ne peut
+donc avoir qu'une seule police en même temps, mais ça va bientôt
+changer. Les paramètres ou et flags sont inutilisés
+pour le moment. Si le nom du fichier fonte est NULL, une fonte par défaut
+sera utilisée.
+
+ int Image_trace_caractere(Image_Desc *im, int x, int y, int code);
+ Cette fonction est très primitive. Elle trace en noir sur un
+ fond blanc en utilisant la fonte courante.
+
+ int Image_trace_chaine_0(Image_Desc *im, char *txt, int x, int y,
+ RGBA *paper, RGBA *ink, int flags);
+ Bah, pas grand chose à dire, à part que le paramètre 'flags' doit
+être mis à zéro,
+et que cette fonction est obsolète , et l'exprime clairement.
+
+ int Image_trace_chaine_1(Image_Desc *im, char *txt, int x, int y,
+ char *nomfonte, RGBA *paper, RGBA *ink);
+ Voici donc la nouvelle fonction pour écrire du texte 8x8 dans une image.
+Elle fonctionne en gros comme son ancêtre, mais permet en plus de spécifier
+un nom de fonte. Si celui-ci est NULL , c'est la dernière fonte
+chargée qui sera utilisée.
+
+ int Image_texte_fonte(char *nomfonte, char *nomtga);
+ Donc voilà le kludge. La seule valeur humainement supportable
+pour le paramètre nomfonte , c'est NULL et les insultes
+parce que çamarchpa , c'est pour moi.
+
+
+
+haut de page
+fonte 16 x 24 Enfin, ça y est, un support primitif des grosses fontes bitmap en
+16x24 est en train de voir le jour. La description des dessins de caractères
+se fait dans un fichier texte spécialement prévu pour être manipulable
+par des outils Unix tels que awk . Ce fichier est une suite
+d'enregistrements contenant le code ascii du caractère considéré, suivi
+de 24 lignes contenant les pixels. Exemple:
+
+
+
+60
+................
+................
+................
+..........**....
+.........***....
+........**......
+.......**.......
+......**........
+.....**.........
+....**..........
+...**...........
+..***...........
+...**...........
+....**..........
+.....**.........
+......**........
+.......**.......
+........**......
+.........***....
+..........**....
+................
+................
+................
+................
+
+Le nombre en première ligne est le code ascii du caractère, exprimé en
+décimal. En fait, ce n'est pas exactement le code ascii, puisque ça peut
+très bien être de l'iso-8859-1 par exemple, donc un code compris entre 0 et
+255. Et les 24 lignes suivantes contienne le dessin du caractère fait
+avec des points et des étoiles.
+
+
+
+
+
+int Image_t16x24_txtload(char *fontname, U_BYTE *zone, int flag);
+ Chargement d'une fonte à partir du fichier texte décrit plus haut.
+Le second paramètre est inutilisé. Le contenu de la fonte est stockée
+dans une zone statique privé, il est donc actuellement impossible
+de gérer plusieurs fontes simultanément. Le flag à 1 demande
+l'effacement préalable de cette zone statique.
+
+ int Image_t16x24_pltch_exp(Image_Desc *img, int lettre, int xpos, int ypos);
+ Dessin d'un caractère 16 x 24 dans une image, les noms des paramètres sont
+explicites. Les couleurs sont fixées. Aucun contrôle de débordement n'est fait.
+
+ int Image_t16x24_pltch_1(Image_Desc *img, int lettre, int xpos, int ypos,
+ RGBA *pap, RGBA *ink, int flags);
+ Dessin d'un caractère 16 x 24 dans une image, les noms des paramètres sont
+presque explicites. La police doit être chargée à l'avance. flags
+doit être mis à 0. Aucun contrôle de débordement n'est fait.
+
+ int Image_t16x24_allchars(char *fontname, char *tganame, int flag);
+ Construction d'une image contenant le dessin des 256 caractères.
+
+
+Voilà , c'est tout pour le moment, mais ça permet déja de faire des
+choses. Je continue à réfléchir aux nouveaux features que je
+vais pouvoir inventer. Restez à l'écoute...
+
+
+haut de page
+outils 16 x 24
+Hop, hop, quelques trucs supplémentaires. Dans le
+tarball , vous trouvererez fnt8to16 qui
+convertit une fonte 8x8 en fonte 16x24. C'est un peu cru, il n'y a pas
+d'interpolation, mais ça donne de quoi faire.
+
Dans le tarball vous trouverez la fonte ci-dessus (fichier
+16x24thin ) qui sera installé comme les autres fontes.
+Dans les
+outils associés ,
+le programme tga_mires peut maintenant tracer le contenu d'une
+fonte 16x24, modulo le parsage des paramètres de la ligne de commande.
+
+
+haut de page
+
+
+Une nouveauté de 2014 (codenamed: rouille de seiche )
+encore très immature. Ces fonctions utilisent les
+fontes 8x8 mise aux échelles en X et en Y,
+sans interpolation, d'où le nom de gropixels .
+
+
+
+int Image_trace_big_char_0(Image_Desc *im,
+ int x, int y, int code, int kx, int ky);
+ Première version du tracé de caractère 'gropixels'.
+ Les paramètres kx et ky sont les coefficients de
+ mise à l'échelle. Il est nécessaire d'avoir préalablement chargé
+ une fonte avec Image_load_fnt8x8 .
+
+ int Image_txt1_big_0(Image_Desc *im, char *txt, int x, int y,
+ int xf, int yf);
+ Première version du tracé de chaine en 'gropixels'. Hélas, pas
+ de contrôle des limites, donc coredump presque assuré.
+
+
+
+haut de page
+liens
+Bah, euh... Freetype , par exemple.
+Mais je suis aussi à la recherche d'un format de fontes 'bitmap' évolué,
+bien documenté et disposant d'un éditeur sous X11 facile
+d'utilisation.
+
+
+
+
+
+
+
diff --git a/Doc/img-warp.html b/Doc/img-warp.html
new file mode 100644
index 0000000..f3ac971
--- /dev/null
+++ b/Doc/img-warp.html
@@ -0,0 +1,88 @@
+
+
+libimage: les warps
+libimage / les warps
+dernière mise à jour: 30 janvier 2009
+# et
+#
+
+
+
+
+
+
+Bon, soyons clair, je suis une grosse faignasse, et ici vous ne trouverez
+rien d'utilisable. Enfin si, un peu, mais fluctuant.
+Il faut donc utsl .
+
+
+
+
+
+
+int Image_center_rotate(Image_Desc *src, Image_Desc *dst, double angle);
+ rotulationne de la image. L'angle est exprimé en degrés. L'interpolation
+ est foireuse.
+
+
+int Image_shift_xy(Image_Desc *src, Image_Desc *dst, int ox, int oy);
+ Déplacement de l'image en X et Y. J'ai l'impression que ça ne marche pas
+ si les offsets sont négatifs...
+
+
+
+haut de page
+interpolate
+/O\ oh ma tête...
+
+
+haut de page
+zoom
+/O\ oh ma tête...
+
+
+int Image_essai_zoom(Image_Desc *src, Image_Desc *dst, int kx, int ky, int flags)
+ Fonction à prototype fluctuant destiné à essayer des trucs et
+des machins zoomants.
+
+haut de page
+liens
+Bah, euh... Non, rien...
+
+
+
+
+haut de page
+
+
+
+
+
diff --git a/Doc/libimage.css b/Doc/libimage.css
new file mode 100644
index 0000000..184edb2
--- /dev/null
+++ b/Doc/libimage.css
@@ -0,0 +1,78 @@
+/*
+ * limimage.css - new 6 juillet 2007
+ */
+
+body { background-color: #f8f8f8; color: #220000;
+ margin-left: 28px; margin-right: 28px;
+}
+
+h1 { color: #335533;
+text-align: center; font-family: sans-serif;
+}
+
+h2 { color: #335533;
+/* border-top-color: #335533; border-top-style: solid; border-top-width: 1px; */
+text-align: center; font-family: sans-serif;
+padding-bottom: 3px;
+}
+h3 { color: #335533; font-family: sans-serif;}
+h4 { color: #335533; font-family: sans-serif;}
+h5 { color: #335533; text-align: center; font-family: sans-serif;}
+
+p {
+ text-indent: 2em; text-align: justify;
+ }
+
+/* boite pour les menus de haut de page */
+p.menuhaut {
+ text-align: center;
+ border-color: #808000; border-style: dotted;
+ border-width: 1px;
+ margin: 10px; padding: 10px;
+ overflow: visible;
+ }
+
+p.footer {
+ text-align: right; color: #000000; font-size: smaller;
+ border-color: #000000; border-style: solid; border-width: 1px;
+ }
+
+p.explique {
+ color: #101010;
+ background-color: #a0a0a0;
+ margin: 10px;
+ padding: 10px;
+ }
+
+p.HDP {
+ background-color: #909090;
+ text-align: center;
+ font-family: sans-serif; font-size: smaller;
+ }
+
+.proto dt {
+ background-color: #ceeece;
+ color: #003300;
+ font-family: monospace;
+ }
+
+.proto dd {
+ color: #000030;
+ text-indent: 0; text-align: justify;
+ padding-bottom: 1em;
+ margin-right: 28px;
+ }
+
+hr { color: red }
+tt { background-color: #dcffdc; color: #000022; }
+
+pre.code {
+ background-color: black; color: lightgreen;
+ padding-bottom: 7px; padding-top: 7px;
+ margin-left: 80px; margin-right: 80px;
+ }
+
+table { border-collapse: collapse; }
+
+td,th { padding: 5px; background: #ffffff; border: 1px solid; }
+
diff --git a/Doc/libimage.html b/Doc/libimage.html
new file mode 100644
index 0000000..4f7b7ba
--- /dev/null
+++ b/Doc/libimage.html
@@ -0,0 +1,241 @@
+
+
+libimage: la doc, enfin !
+
+dernière mise à jour : 15 décembre 2015
+
+
+
+
+libimage est une librairie de traitement de les images que j'ai
+fabriquée moi-même avec mon
+vim gcc & g77 procédure d'installation est à peu
+près explicite.
+
+
+
+Il est difficile de décrire ce que font certaines fonctions, vous devrez donc
+les essayer par vous même pour vous faire une idée. Et en cas de doute, vous
+avez les
+sources
+Ã votre disposition.
+utsl .
+Il existe aussi quelques exemples d'utilisation
+dans la vie réelle.
+
+
+
+
+
+Image_Desc * Image_alloc(int w, int h, int type)
+ Création d'une nouvelle image. Les types valides sont:
+ IMAGE_GREY, IMAGE_RGB et IMAGE_RGBA. En fait, les images en niveaux de
+ gris sont très mal gérées... !!! le contenu de l'image n'est
+ pas initialisé. Son contenu est allé à Toire. Il faut utiliser
+ Image_clear pour l'effacer.
+
+ int Image_DeAllocate(Image_Desc *)
+ Restitution de la mémoire 'pixel' d'une image. Attention, la mémoire
+du descripteur n'est pas rendue. C'est probablement un
+bug .
+
+ Image_Desc * Image_clone(Image_Desc *i, int copie)
+ Crée une copie d'une image de même type. Si le flag copie est
+ TRUE , les pixels sont recopiés dans la nouvelle image.
+
+ int Image_clear( Image_Desc *image, int r, int g, int b)
+ Remplissage d'une image avec les rgb fournis.
+28 Déc 2001 : si un canal alpha est présent, il est mis à 0.
+
+ int Image_plotRGB(Image_Desc *i, int x, int y, int r, int g, int b)
+ Ecrire un pixel dans une image, avec vérification des limites.
+
+ int Image_plot_channel(Image_Desc *img, char channel, int x, int y, int value)
+ Cette fonction permet de modifier un seul des canaux de l'image.
+ Le paramètre 'channel' est un char 'r', 'g', 'b', 'R', 'G' ou 'B'.
+ Le canal alpha n'est pas encore géré.
+
+ int Image_getRGB(Image_Desc *i, int x, int y, int *pr, int *pg, int *pb)
+ Lecture d'un pixel. En rajoutant un 'A' au nom de la fonction, et un
+ quatrième pointeur sur int , on peut aussi lire le canal
+ alpha .
+
+ Image_print_version(int flag)
+ Affiche sur stdout la version de la librairie. Si flag
+ est != 0, il y a des informations complémentaires. Si flag > 1 certaines
+ options de compilation et/ou d'installation sont aussi affichées.
+ Vous disposez également d'un #define IMAGE_VERSION_STRING
+ utilisable dans un
+ printf ("version %s\n", IMAGE_VERSION_STRING); de bon aloi.
+ Attention quand même, si vous utilisez ce #define dans un programme
+ lié avec la bibliothèque dynamique, puis que vous passiez à une
+ version différente de la libimage, la version affichée par votre programme
+ ne sera plus cohérente.indispensable .
+ C'est auprès de moi qu'il faut raler.
+
+
+
+haut de page
+
+
+
+Différentes routines utilitaires, destinées avant tout à la mise au point
+des applications, mais qui ne sont pas interdites aux péones , loin
+de là .
+
+
+
+
+int Image_dump_descriptor(Image_Desc *im, char *text);
+ Affiche, de façon désordonnée, les informations disséminées dans un
+ descripteur d'image Image_desc .
+
+ int Image_dump_rect(Image_Rect *rect, char *texte, int flag);
+ Affiche le contenu d'une structure Image_Rect. Un flag différent de
+ zéro rajoute l'autre coin (pan ) et la surface.
+
+ int Image_fabrique_une_mire(Image_Desc *im, RGB_map *map);
+ Euh, ça devrait en principe marcher avec une image 320x200.
+ Il existe d'autres mires dans le truc.
+
+ Les chronomètres:
+On dispose de 42 chronomètres. Etonnant, non?void Image_start_chrono(char *texte, int num_chrono); long Image_stop_chrono(char *texte, int num_chrono);
+
+
+
+
+Il y a aussi, dans le genre relativement utile,
+ le marquage des images.
+
+
+
+
+haut de page
+
+
+
+A la lecture du fichier tthimage.h vous avez constaté une série de #define
+pour les codes d'erreur. La fonction char * Image_err2str(int codeerr)
+permet d'obtenir un texte explicatif. Vous pouvez par exemple écrire:
+
+
+ foo = Image_blabla(gniark);
+ printf("retour from hell: %s\n", Image_err2str(foo));
+
+
+
+
+
+char * Image_err2str(int codeerr);
+ Conversion du code numérique de retour des fonctions en texte
+ klingonesquement compréhensible. Si la valeur envoyée n'est pas
+ gérée, un message bidon est fabriqué à la volée.
+ void Image_print_error(char * texte, int err);
+ Affichage d'un message décrivant une erreur. Si le texte commence par
+le caractère '-', c'est sur stdout , sinon, c'est sur stderr .
+Les numéros d'erreur sont à décrypter dans tthimage.h .
+
+
+
+Je suis vraiment désolé, mais je suis totalement incapable
+de fournir une liste détaillée, avec des explications, de tout
+les codes d'erreur. Pourtant, ça serait bien comfortable.
+
+haut de page
+
+
+
+J'ai enfin confectionné quelques
+ utilitaires pour la ligne de
+ commande qui appellent des primitives de la librairie. Ils sont
+ ici et
+ je vous invite à en lire les sources. C'est un bon point de départ pour
+ apprendre à utiliser le bidule.
+ Le postprocessing des images des
+ Sources de Tar a été
+ fait avec libimage: combinaison de deux variantes de l'image faite par
+ POV et divers effets de cadres.
+
+
+
+En conclusion, vous êtes livré à vous-même avec ce kludge, mais j'espère
+que vous trouverez autant de fun à l'utiliser que j'en ai à le faire.
+Et je vous rappelle que ce logiciel est diffusé sous la bienveillante
+protection de la DMZIZ licence que vous pouvez trouver
+par là .
+
+
+
+
+
+Pour les fous de la fabrication d'images:
+ Povray et
+ Fractint .
+ Pour les cinglés de la manipulation d'image:
+ Gimp qui roulaize grave pour les
+ clicketeurs, et image-magick
+ pour les batcheurs.
+
+
+
+
+
+
+
+
diff --git a/README.md b/README.md
index 27bd44a..fd21432 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
# libtthimage
-Du code né dans les années 1986 sur un Kenitec 286 sous msdos 4 ou 5, qui s'est un jour retrouvé dans un Linux (kernel 0.99) et qui végète depuis ~2005
-
-Il a pour but de brotcher les images avec vigueur.
-
+Du code né dans les années 1986 sur un Kenitec 286 sous msdos 4 ou 5,
+qui s'est un jour retrouvé dans un Linux (kernel 0.99) et qui végète
+depuis ~2005. Il est venu le temps de le remettre en route.
+
+Il a pour but de brotcher les images avec vigueur.
+
+
+
diff --git a/foo.c b/foo.c
new file mode 100644
index 0000000..6f42125
--- /dev/null
+++ b/foo.c
@@ -0,0 +1,12 @@
+#include
+#include
+#include
+#include
+
+#include "tthimage.h"
+
+int main(int argc, char *argv[])
+{
+Image_print_version(2);
+return 0;
+}
diff --git a/image.c b/image.c
new file mode 100644
index 0000000..c1d07dc
--- /dev/null
+++ b/image.c
@@ -0,0 +1,595 @@
+/*
+ fonctions de bases pour la librairie 'libimage'
+ -----------------------------------------------
+
+ (g) 1992,2003 - Thierry Boudet - aka Oulala
+
+*/
+
+#include
+#include
+#include
+
+#include "tthimage.h"
+
+/*::------------------------------------------------------------------::*/
+void
+Image_print_version(int flag)
+{
+char *ptr;
+
+fflush(stdout);
+printf("-+- This is the `image' library v%s (dwtfywl 2022) tTh\n",
+ IMAGE_VERSION_STRING);
+if (flag)
+ {
+/* this information is only correct IF you touch image.c before
+ * running 'make' utility */
+ printf(" + compiled : %s, %s\n", __DATE__, __TIME__);
+ }
+if (flag > 1)
+ {
+ printf(" + DESTDIR = %s\n", DESTDIR);
+ printf(" + SHAREDIR = %s\n", SHAREDIR);
+ printf(" + CC OPTS = %s\n", CC_OPTS);
+ }
+fflush(stdout);
+
+/* OMFG, this is a gnuism ! */
+if ( (ptr=getenv("MALLOC_CHECK_")) != NULL)
+ {
+ fprintf(stderr, "-+- libimage: malloc check is set to %s\n", ptr);
+ }
+
+#if DEBUG_LEVEL
+fprintf(stderr,
+ "Warning! this version of libimage is compiled with DEBUG_LEVEL=%d\n",
+ DEBUG_LEVEL);
+ #if FORCE_ABORT
+fprintf(stderr, "Warning! this version of libimage is compiled with FORCE_ABORT!\n");
+ #endif
+#endif
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * This function create a new channel for an image.
+ * Before version 0.4.9 it was a private function, but
+ * the module 'alpha.c' need access to it.
+ *
+ * ... So I make it "semi-public" ... */
+int Image_alloc_pixels(unsigned char ***pix, int w, int h);
+/*
+ * pour le moment, pas de code retour en cas
+ * d'erreur, mais un exit(1) brutal.
+ */
+int Image_alloc_pixels(unsigned char ***pix, int w, int h)
+{
+int foo;
+unsigned char **lignes, *ptr;
+
+lignes = (unsigned char **)malloc(sizeof(unsigned char *) * h);
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, " alloc pixels for plane @ %p -> %p\n", pix, lignes);
+#endif
+
+*pix = lignes; /* setting the indirected return value here
+ so we can use 'lignes' in the loop. */
+
+for (foo=0; foo don't "free" this pointer, please.
+ */
+Image_Desc *
+Image_alloc(int width, int height, int type)
+{
+Image_Desc *header;
+int foo;
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "allocation for an image %dx%d, type:%d\n",
+ width, height, type);
+#endif
+
+if ( (header=(Image_Desc *)calloc(sizeof(Image_Desc), 1)) == NULL )
+ {
+ fprintf(stderr, "Image_Alloc (%s) err malloc header\n", __FILE__);
+ exit(1);
+ }
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, " header is at @ %p\n", header);
+#endif
+
+strcpy(header->name, "");
+header->nb_planes = type;
+header->width = width; header->height = height;
+#if IMGCOMMENT
+strcpy(header->comment, "* libimg is (dwtfywl) tontonTh 2022 *");
+#else
+/*
+ * The old 'Xv' image viewer does not like .TGA with a comment.
+ */
+strcpy(header->comment, "");
+#endif
+
+header->type = type;
+header->Rpix = header->Gpix = header->Bpix = header->Apix = NULL;
+
+header->magic = MAGIC_OF_IMAGE;
+
+header->nbcols = 0;
+header->idx_palette = 0;
+header->errmsg = header->modified = 0;
+
+/* nouveau 18 Sept 2001 */
+header->fx = header->fy = 0.0;
+header->fw = (double)width;
+header->fh = (double)height;
+
+/* new 12 Nov 2001 - see 'turtle.c' */
+header->rt = header->gt = header->bt = 42;
+header->xt = (double)width / 2.0;
+header->yt = (double)height / 2.0;
+header->at = 0; /* canal alpha, 0 est-il la bonne valeur ? */
+
+switch (type)
+ {
+ case IMAGE_GREY:
+ Image_alloc_pixels(&header->Rpix, width, height);
+ for (foo=0; foo<256; foo++)
+ {
+ header->palette[0][foo] = foo;
+ header->palette[1][foo] = foo;
+ header->palette[2][foo] = foo;
+ }
+ break;
+
+ case IMAGE_RGB:
+ Image_alloc_pixels(&header->Rpix, width, height);
+ Image_alloc_pixels(&header->Gpix, width, height);
+ Image_alloc_pixels(&header->Bpix, width, height);
+ break;
+
+ case IMAGE_RGBA:
+#if DEBUG_LEVEL
+ fprintf(stderr, "WARNING! allocating an image with alpha channel,\n");
+#endif
+ Image_alloc_pixels(&header->Rpix, width, height);
+ Image_alloc_pixels(&header->Gpix, width, height);
+ Image_alloc_pixels(&header->Bpix, width, height);
+ Image_alloc_pixels(&header->Apix, width, height);
+ break;
+
+ default:
+ fprintf(stderr, "***** %s alloc image: %d is an unknow type *****\n",
+ __FILE__, type);
+ return NULL;
+ }
+
+if (getenv("MALLOC_CHECK_") != NULL)
+ {
+ fprintf(stderr, "-+- libimage %s %d: alloc %p\n",
+ __FILE__, __LINE__, header);
+ }
+
+return header;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ This fonction build another image from a model.
+ */
+Image_Desc *
+Image_clone (Image_Desc *src, int copy)
+{
+Image_Desc *image;
+
+if ( src==NULL )
+ {
+ fprintf(stderr, "Image_clone: source descriptor is NULL\n");
+ exit(5);
+ }
+
+image = Image_alloc(src->width, src->height, src->type);
+if ( image==NULL )
+ {
+ fprintf(stderr, "Image_clone: cloned descriptor is NULL\n");
+ exit(5);
+ }
+
+/*
+ * we have to transfer a few attributes ...
+ */
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "clone %p to %p, no copy of attributes ?\n", src, image);
+#endif
+
+image->fx = src->fx; image->fy = src->fy;
+image->fw = src->fw; image->fh = src->fh;
+
+if (copy == 1)
+ {
+ Image_copy(src, image);
+ }
+image->modified = 0; /* 8 Fev 01 */
+
+return image;
+}
+/*::------------------------------------------------------------------::*/
+int Image_copy_comment(Image_Desc *s, Image_Desc *d)
+{
+#if DEBUG_LEVEL
+fprintf(stderr, "%s ( %p -> %p )\n", __func__, s, d);
+#endif
+
+/* TODO check the validity of the comment, there _must_ be a '\0' inside */
+
+memcpy(d->comment, s->comment, IMG_OBJCOMMENT_LEN);
+
+return FUNC_IS_ALPHA;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * Helas, cette fonction ne marche que sur les images RGB
+ * et comment la rendre compatible tout-types sans tout casser ?
+ */
+int
+Image_clear( Image_Desc *image, int r, int g, int b )
+{
+int x, y;
+
+if (image->type == IMAGE_RGB)
+ {
+ for (y=0; yheight; y++)
+ {
+ /*
+ * XXX here we can go faster with a few memset
+ */
+ for (x=0; xwidth; x++)
+ {
+ (image->Rpix[y])[x] = r;
+ (image->Gpix[y])[x] = g;
+ (image->Bpix[y])[x] = b;
+ /* Bon, et le canal Alpha, il devient quoi ? */
+ }
+ }
+ return 0; /* ok, this 'return' here is a "spleyterie" :) */
+ }
+
+if (image->type == IMAGE_RGBA)
+ {
+ for (y=0; yheight; y++)
+ {
+ for (x=0; xwidth; x++)
+ {
+ (image->Rpix[y])[x] = r;
+ (image->Gpix[y])[x] = g;
+ (image->Bpix[y])[x] = b;
+ (image->Apix[y])[x] = 0;
+ }
+ }
+ return 0; /* ok, this 'return' here is a "spleyterie" :) */
+ }
+
+fprintf(stderr, "%s : invalid image type %d : %s\n", __func__,
+ image->type, Image_type2str(image->type));
+return IMAGE_BAD_TYPE;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * every image in memory have a comment field, who is writen
+ * in TGA and PNM file when image is saved.
+ */
+int
+Image_set_comment(Image_Desc *image, char *text)
+{
+if (strlen(text) > IMG_OBJCOMMENT_LEN)
+ return STRING_TOO_LONG;
+strcpy(image->comment, text);
+return OLL_KORRECT;
+}
+/* 10 nov 2001: no #define for this not-so-magic 254 value ? */
+/*::------------------------------------------------------------------::*/
+int
+Image_plot_gray(Image_Desc *img, int x, int y, int v)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERRPLOT X %4d Y %4d %d\n", x, y, v);
+ return OUT_OF_IMAGE;
+ }
+(img->Rpix[y])[x] = (uint8_t)v;
+ /* POURQUOI on ne plotte qu'une composante ? XXX */
+
+return OLL_KORRECT;
+}
+
+int Image_plotRGB(Image_Desc *img, int x, int y, int r, int g, int b)
+{
+
+#if DEBUG_LEVEL > 2
+fprintf(stderr, "PLOTRGB %d %d\n", x, y);
+#endif
+
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "Errplot RGB X=%d, Y=%d %d, %d, %d\n", x, y, r, g, b);
+#if FORCE_ABORT
+ abort();
+#endif
+ return OUT_OF_IMAGE;
+ }
+(img->Rpix[y])[x] = (uint8_t)(r&0xff);
+(img->Gpix[y])[x] = (uint8_t)(g&0xff);
+(img->Bpix[y])[x] = (uint8_t)(b&0xff);
+return OLL_KORRECT;
+}
+
+int Image_plotRGBA(Image_Desc *img, int x, int y, int r, int g, int b, int a)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+/* may be an #if DEBUG_LEVEL here ? */
+ fprintf(stderr, "Errplot RGBA X %4d Y %4d %d, %d, %d, %d\n",
+ x, y, r, g, b, a);
+#if FORCE_ABORT
+ abort();
+#endif
+ return OUT_OF_IMAGE;
+ }
+
+(img->Rpix[y])[x] = (uint8_t)(r&0xff);
+(img->Gpix[y])[x] = (uint8_t)(g&0xff);
+(img->Bpix[y])[x] = (uint8_t)(b&0xff);
+(img->Apix[y])[x] = (uint8_t)(a&0xff);
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+int
+Image_getRGB(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+/* may be an #if DEBUG_LEVEL here ? */
+ fprintf(stderr, "ERR GETRGB X %4d Y %4d\n", x, y);
+#if FORCE_ABORT
+ abort();
+#endif
+ return OUT_OF_IMAGE;
+ }
+
+*pr = (int)((img->Rpix[y])[x]);
+*pg = (int)((img->Gpix[y])[x]);
+*pb = (int)((img->Bpix[y])[x]);
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+int
+Image_getRGBA(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb, int *pa)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERR GETRGBA X %4d Y %4d\n", x, y);
+#if FORCE_ABORT
+ abort();
+#endif
+ return OUT_OF_IMAGE;
+ }
+
+if (img->type != IMAGE_RGBA)
+ {
+ fprintf(stderr, "Image get RGBA: bad image type: %d, %s\n",
+ img->type, Image_type2str(img->type));
+#if FORCE_ABORT
+ abort();
+#endif
+ exit(7); /* et un code d'erreur, ça irais pas mieux */
+ }
+*pr = (int)((img->Rpix[y])[x]);
+*pg = (int)((img->Gpix[y])[x]);
+*pb = (int)((img->Bpix[y])[x]);
+*pa = (int)((img->Apix[y])[x]);
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * ecriture d'une des composantes de l'image. (new=2000-02-01)
+ *
+ * 15 mars 2003: l'interface Fortran est dans 'img77g.c' XXX
+ */
+int Image_plot_channel(Image_Desc *img, char channel, int x, int y, int value)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+#if DEBUG_LEVEL
+ fprintf(stderr, "ERR PLOTCHANNEL X %4d Y %4d\n", x, y);
+#endif
+ return OUT_OF_IMAGE;
+ }
+
+switch (channel)
+ {
+ case 'r': case 'R': (img->Rpix[y])[x] = (uint8_t)(value&0xff); break;
+ case 'g': case 'G': (img->Gpix[y])[x] = (uint8_t)(value&0xff); break;
+ case 'b': case 'B': (img->Bpix[y])[x] = (uint8_t)(value&0xff); break;
+ case 'a': case 'A': (img->Apix[y])[x] = (uint8_t)(value&0xff); break;
+ default: return WRONG_CHANNEL;
+ }
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ lecture d'une des composantes de l'image.
+ */
+int
+Image_R_pixel(Image_Desc *img, int x, int y)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERR READ R PIX X%d Y%d\n", x, y);
+ return OUT_OF_IMAGE;
+ }
+return (int)((img->Rpix[y])[x]);
+}
+
+int
+Image_G_pixel(Image_Desc *img, int x, int y)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERR READ G PIX X%d Y%d\n", x, y);
+ return OUT_OF_IMAGE;
+ }
+return (int)((img->Gpix[y])[x]);
+}
+
+int
+Image_B_pixel(Image_Desc *img, int x, int y)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERR READ B PIX X%d Y%d\n", x, y);
+ return OUT_OF_IMAGE;
+ }
+return (int)((img->Bpix[y])[x]);
+}
+
+int
+Image_A_pixel(Image_Desc *img, int x, int y)
+{
+if ( x<0 || y<0 || x>=img->width || y>=img->height )
+ {
+ fprintf(stderr, "ERR A PIX X%d Y%d\n", x, y);
+ return OUT_OF_IMAGE;
+ }
+return (int)((img->Apix[y])[x]);
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * no boundary control ?
+ */
+int
+Image_pixel_copy(Image_Desc *s, int x, int y, Image_Desc *d, int i, int j)
+{
+
+(d->Rpix[j])[i] = (s->Rpix[y])[x];
+(d->Gpix[j])[i] = (s->Gpix[y])[x];
+(d->Bpix[j])[i] = (s->Bpix[y])[x];
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * Le nom de cette fonction n'a pas trop de rapport avec ce qu'elle fait,
+ * mais elle permet de faire reculer Crash Coredump.
+ */
+int
+Image_compare_desc(Image_Desc *a, Image_Desc *b)
+{
+char *fmt = "Image at %p have no 'Dead Beef' in it\n";
+
+if ( (a==NULL) || (b==NULL) ) return NULL_DESCRIPTOR;
+
+if ( a->magic != MAGIC_OF_IMAGE )
+ {
+ fprintf(stderr, fmt, a);
+ return NOT_AN_IMAGE_DESC;
+ }
+if ( b->magic != MAGIC_OF_IMAGE )
+ {
+ fprintf(stderr, fmt, a);
+ return NOT_AN_IMAGE_DESC;
+ }
+
+if ( a->width != b->width ) return DIFFERENT_WIDTH;
+if ( a->height!= b->height) return DIFFERENT_HEIGHT;
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ Cette fonction ne rend pas toute la memoire
+ Pour le moment, le header n'est pas restitue.
+
+ le probleme, si on desalloue le header
+ c'est qu'il reste un pointeur fou chez
+ l'appelant ...
+*/
+
+int
+Image_DeAllocate(Image_Desc *im)
+{
+int line;
+
+if (getenv("MALLOC_CHECK_") != NULL) {
+ fprintf(stderr, "-+- libimage %s %d: free %p\n",
+ __FILE__, __LINE__, im);
+ }
+
+if ( im->magic != MAGIC_OF_IMAGE ) {
+ fprintf(stderr, "at %p, there was no 'Dead Beef' to deallocate\n", im);
+ /* emergency exit */
+ abort();
+ }
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, ">> de-allocating image %p, cross your fingers.\n", im);
+fprintf(stderr, " %p %p %p %p\n", im->Rpix, im->Gpix, im->Bpix, im->Apix);
+#endif
+
+im->magic = 0L; /* mark dirty/invalid. */
+im->type = IMAGE_NONE; /* -1, et tusors */
+
+if (im->Rpix != NULL)
+ {
+ for (line=0; lineheight; line++)
+ if (im->Rpix[line] != NULL) free(im->Rpix[line]);
+ free(im->Rpix); im->Rpix = NULL;
+ }
+
+if (im->Gpix != NULL)
+ {
+ for (line=0; lineheight; line++)
+ if (im->Gpix[line] != NULL) free(im->Gpix[line]);
+ free(im->Gpix); im->Gpix = NULL;
+ }
+
+if (im->Bpix != NULL)
+ {
+ for (line=0; lineheight; line++)
+ if (im->Bpix[line] != NULL) free(im->Bpix[line]);
+ free(im->Bpix); im->Bpix = NULL;
+ }
+
+if (im->Apix != NULL)
+ {
+ for (line=0; lineheight; line++)
+ if (im->Apix[line] != NULL) free(im->Apix[line]);
+ free(im->Apix); im->Apix = NULL;
+ }
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "DeAllocate >> are we alive ?\n");
+#endif
+
+return OLL_KORRECT;
+}
+/*::------------------------------------------------------------------::*/
diff --git a/tthimage.h b/tthimage.h
new file mode 100644
index 0000000..316df03
--- /dev/null
+++ b/tthimage.h
@@ -0,0 +1,1383 @@
+/*
+ tthimage.h
+ ----------
+ http:///la.buvette.org/devel/libimage/
+*/
+#ifndef IMAGE_VERSION_STRING
+ #define IMAGE_VERSION_STRING "0.4.43"
+
+/*::------------------------------------------------------------------::*/
+/*
+ * ces trois 'typedef' demandent des verifications
+ * message poste a Linux-31 le 16 Octobre 1998
+ *
+ * les reponses recues semblent indiquer que c'est
+ * correct. verifications quand j'aurais une HP Pa-Risc
+ * ou un Alpha, ou mieux, une Playstation 2.
+ *
+ * Octobre 2001: on dirait que ca marche sur Sparc/Solaris.
+ * Octobre 2009: on dirait que ca marche sur Sparc64/OpenBSD.
+ *
+ * Fevrier 2014: pourquoi ne pas utiliser ?
+ */
+#include
+
+/*
+ * les differents types d'images que on gere, nous ici
+ */
+#define IMAGE_NONE 0
+#define IMAGE_GRAY 1
+#define IMAGE_GREY 1 /* common typo */
+#define IMAGE_RGB 3
+#define IMAGE_RGBA 4
+#define IMAGE_ALPHA 6 /* only the alpha channel */
+#define IMAGE_PAL 10
+#define IMAGE_PORTNAWAK 27212 /* you bastard */
+
+/*
+ * sometime, specially in the Fortran interface, we need a
+ * buffer for filename storage. Here is the max size for this
+ * buffer: a really magic number :)
+ */
+#define IMG_FILENAME_LEN 4242
+
+/*
+ * some objects (structs) in the library have a name field
+ * and/or a comment field.
+ * here is the size of this field.
+ */
+#define IMG_OBJNAME_LEN 80
+#define IMG_OBJCOMMENT_LEN 256
+
+/*
+ * we use environment variables
+ */
+
+#define ENV_DEFAULT_RGBA "TGA_DEFAULT_RGBA"
+#define ENV_LIBIMAGE_PATH "LIBIMAGE_PATH"
+
+/*
+ * descripteur d'une image en memoire
+ * ----------------------------------
+ */
+#define MAGIC_OF_IMAGE 0xdeadbeef
+
+typedef struct {
+ unsigned long magic;
+ char name[IMG_OBJNAME_LEN+2];
+ int width, height;
+ int type; /* voir #define plus haut */
+ int nb_planes;
+ uint8_t **Rpix, **Gpix, **Bpix, **Apix;
+ int idx_palette;
+ uint8_t palette[3][256];
+ int nbcols;
+ char comment[IMG_OBJCOMMENT_LEN+2];
+ int errmsg; /* not used */
+ int modified;
+ double fx, fy, fw, fh; /* nouveau 18 Sept 2001 */
+ int rt, gt, bt, at; /* color of turtle */
+ double xt, yt; /* position of turtle */
+ double ht; /* angle of turtle (heading) */
+
+ int reserve[8];
+ } Image_Desc;
+
+/*=== macros for accessing the image descriptor ===*/
+#define IMG_WIDTH(i) ((i)->width)
+#define IMG_HEIGHT(i) ((i)->height)
+#define IMG_TYPE(i) ((i)->type)
+
+/*
+ * this structure serve as a sub-image descriptor
+ */
+typedef struct {
+ int x, y;
+ int w, h;
+ long reserved;
+ } Image_Rect;
+
+/*
+ * new 11 Jan 2003: a struc like an Image_Rect, but with
+ * double precision floating point coords.
+ */
+typedef struct {
+ double x, y;
+ double w, h;
+ int kdr; /* what is it ? */
+ long reserved;
+ } Image_dblRect;
+
+/* new 11 Nov 1999
+ * a RGBA quadruplet
+ */
+typedef struct {
+ short r, g, b, a;
+ int reserved;
+ int reserved2;
+ } RGBA;
+
+/*
+ * memory descriptor for bits-planes
+ * 27 Dec 2001: c,a devient quoi, cette histoire de bitmaps ?
+ * 17 mars 2010: du code commence a venir...
+ *
+ */
+typedef struct {
+ unsigned int magic;
+ int width, height;
+ unsigned int id;
+ uint8_t r0, g0, b0, r1, g1, b1;
+ char name[IMG_OBJNAME_LEN+2];
+ unsigned char tagname;
+ unsigned char *plane;
+ int reserved;
+ } A_BitPlane;
+
+#define MAGIC_BIT_PLANE 0xb142ae17
+
+/*
+ * this structure describe a color MAP 'a la fractint'
+ * see 'load' and 'save' code in palettes.c
+ */
+typedef struct {
+ short nbre;
+ char name[IMG_OBJNAME_LEN+2];
+ short red[256];
+ short green[256];
+ short blue[256];
+ int reserved;
+ } RGB_map;
+
+/*
+ * new: 2001 october. ymmv.
+ * Context for 3D plotting
+ */
+typedef struct {
+ unsigned long magic;
+ Image_Desc *img;
+ int valid;
+ char name[IMG_OBJNAME_LEN+2];
+ int reserved;
+ } Context_3D;
+
+/*
+ * 27 Dec 2001: a point in 2D space with some attributes.
+ * will be used in pov hf functions...
+ */
+typedef struct
+ {
+ short x, y; /* pixel position */
+ short h; /* pixel value */
+ short c; /* color index ? */
+ } Image_Point;
+
+typedef struct
+ {
+ unsigned long control; /* another DeadBeef ? */
+ char name[IMG_OBJNAME_LEN+2];
+ int width, height; /* dims of reference image ? */
+ int nbre; /* real number of points */
+ int alloc; /* sizeof array */
+ int reserved[4];
+ Image_Point *points;
+ } Image_PtList;
+
+/*
+ * Nouveau 18 fevrier 2008
+ */
+#define MAGIC_OF_DF3 0x0df30df3
+typedef struct
+ {
+ unsigned long control;
+ char name[IMG_OBJNAME_LEN+2];
+ int xdim, ydim, zdim;
+ int nbrbytes; /* 1 2 or 4 */
+ int flags;
+ double scale;
+ double *datas;
+ char blabla[11];
+ } DensityF3Head;
+
+/*
+ * ---------------------------------------
+ */
+#ifndef M_PI
+#define M_PI 3.14159265358979323846 /* pi */
+#endif
+
+/*
+ * ---------------------------------------
+ * now, we #define some useful error codes
+ */
+
+/* BEGIN error_code */
+#define OLL_KORRECT 0
+#define DIFFERENT_WIDTH 2000
+#define DIFFERENT_HEIGHT 2001
+#define NOT_AN_IMAGE_DESC 2002
+#define IMAGE_NO_MEM 2003
+#define IMAGE_TOO_SMALL 2004
+#define UNKNOW_ERROR 2005
+#define STRING_ERROR 2006
+#define IMAGE_BAD_TYPE 2007
+#define STRING_TOO_LONG 2008
+#define NULL_DESCRIPTOR 2009
+#define VERY_STRANGE 2010
+#define DIVISOR_IS_ZERO 2011
+#define DIVISOR_IS_0 2011 /* yes, two name for the same code */
+#define FULL_NUCKED 2012
+#define BUFFER_NO_MEM 2013
+#define FILE_NOT_FOUND 2014
+#define OUT_OF_IMAGE 2015
+#define OUT_OF_PIC 2015 /* alias, don't use it, please */
+#define WRONG_CHANNEL 2016
+#define BAD_COLOR_NUMBER 2017
+#define SCALE_ERROR 2018
+#define MAP_TOO_BIG 2019
+#define SRC_TOO_SMALL 2020
+#define DST_TOO_SMALL 2021
+#define BAD_MAGIC 2024
+#define IMG_OVERWRITE 2027
+#define INVALID_PARAM 2028
+#define BAD_PARAMETER INVALID_PARAM
+#define PROTOCOL_ERROR 2029
+#define RECT_TOO_SMALL 2030
+#define NO_ALPHA_CHANNEL 2031
+#define NO_BETA_CHANNEL 2032
+#define FILE_CREATE_ERR 2033
+#define BAD_ANGLE 2034
+#define WRONG_FLAG 2035
+#define NOT_3D_IMG 2036
+#define INVALID_RGB 2037
+#define TOO_MUCH_VALUES 2038
+#define INVALID_PT_LIST 2039
+#define INVALID_POINT 2040
+#define NULL_POINTER 2041
+#define FMBL_ROULAIZE 2042
+#define PIXEL_OVERFLOW 2043
+#define PIXEL_UNDERFLOW 2044
+#define INVALID_GAMMA 2045
+#define INVALID_HF15 2046
+#define BAD_FILE_NAME 2047
+#define EMPTY_COL_MAP 2048
+#define BAD_CHRONO 2049
+#define IMAGE_BAD_DIMS 2050
+#define PASTIS 2051
+#define BAD_OPERATOR 2052
+#define BAD_FILTER 2053
+#define WTF_OSEF 2054 /* 18 janv 2010 */
+#define BASIC_IO_RD_ERR 2061
+#define BASIC_IO_WR_ERR 2062
+#define FP_GARBAGE 2080 /* c'est quoi ? FIXME */
+#define IMG_ARE_DIFFERENT 2500 /* added by Marcel */
+#define BAD_ZOOM 2550
+#define BAD_GRAY_OP 2660
+#define ERR_GARDRECT 2600
+#define FUNC_IS_ALPHA 2990
+#define FUNC_IS_BETA 2991
+#define FUNC_IS_XPER 2992
+#define FUNC_COREDUMP 2993
+#define FUNC_NOT_FINISH 2999
+#define IMAGE_FAIL 3000
+#define BAD_CADRE 3153
+
+#define ERR_FORTRAN 9999
+/* END error_code */
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module image.c les primitives
+ */
+void Image_print_version(int verbose);
+
+Image_Desc *Image_alloc(int width, int height, int type);
+Image_Desc *Image_clone(Image_Desc *src, int copy);
+int Image_clear( Image_Desc *image, int r, int v, int b );
+int Image_set_comment(Image_Desc *image, char *text);
+int Image_copy_comment(Image_Desc *s, Image_Desc *d);
+
+int Image_plot_gray(Image_Desc *img, int x, int y, int v);
+
+int Image_plotRGB(Image_Desc *img, int x, int y, int r, int g, int b);
+int Image_plotRGBA(Image_Desc *img, int x, int y, int r, int g, int b, int a);
+
+int Image_getRGB(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb);
+int Image_getRGBA(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb, int *pa);
+
+int Image_plot_channel(Image_Desc *img, char channel, int x, int y, int value);
+
+int Image_R_pixel(Image_Desc *img, int x, int y);
+int Image_G_pixel(Image_Desc *img, int x, int y);
+int Image_B_pixel(Image_Desc *img, int x, int y);
+int Image_A_pixel(Image_Desc *img, int x, int y);
+
+int Image_pixel_copy(Image_Desc *s, int x, int y, Image_Desc *d, int i, int j);
+
+int Image_compare_desc(Image_Desc *a, Image_Desc *b);
+
+int Image_DeAllocate( Image_Desc *im ); /* nice coredumper */
+
+/*::------------------------------------------------------------------::*/
+/* module pixels.c */
+
+int Image_XOR_pixel(Image_Desc *img, int x, int y, int r, int g, int b);
+int Image_rot_pixel(Image_Desc *img, int x, int y, int r, int g, int b);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module basic_io.c
+ * exterminons les problemes de Boutisme !-)
+ */
+
+int Image_basicIO_teste_boutisme(char *txt);
+int Image_basicIO_write_I_short(FILE *fp, short value);
+int Image_basicIO_write_M_short(FILE *fp, short value);
+int Image_basicIO_write_I_long(FILE *fp, long value);
+int Image_basicIO_read_I_short(FILE *fp, uint16_t *p);
+int Image_basicIO_read_M_short(FILE *fp, uint16_t *p);
+int Image_basicIO_read_I_long(FILE *fp, uint32_t *p);
+
+/*::------------------------------------------------------------------::*/
+/* module mustopen.c */
+
+int Image_must_open(char *filename, int mode, int type);
+FILE * Image_must_fopen(char *filename, char *mode, int type);
+
+/*::------------------------------------------------------------------::*/
+/* module operat.c */
+
+int Image_adjust_minmax_0(Image_Desc *src, Image_Desc *dst, int yo,
+ int minstone, int maxstone);
+int Image_adjust_minmax_1(Image_Desc *src, Image_Desc *dst, int yo,
+ int minstone, int maxstone);
+int Image_egalise_RGB(Image_Desc *, Image_Desc *, int);
+int Image_egalise_mono_0(Image_Desc *, Image_Desc *, int);
+int Image_luminance(Image_Desc *, Image_Desc *, int);
+int Image_copy(Image_Desc *src, Image_Desc *dst);
+int Image_negate(Image_Desc *, Image_Desc *);
+int Image_clear_component(Image_Desc *img, char component, int value);
+int Image_and_pix( Image_Desc *image, uint8_t ar, uint8_t ag, uint8_t ab);
+int Image_or_pix( Image_Desc *image, int ar, int ag, int ab );
+int Image_copie_seuil(Image_Desc *s, Image_Desc *d, int r, int g, int b);
+int Image_overlay(Image_Desc *s, Image_Desc *d, int xpos, int ypos);
+int Image_overlay_mix(Image_Desc *s, Image_Desc *d, int x, int y, int k);
+int Image_seuil_RGB(Image_Desc *s, Image_Desc *d, int r, int g, int b);
+int Image_AutoSeuilRGB(Image_Desc *s, Image_Desc *d);
+
+int Image_operator(Image_Desc *in, char op, int val, Image_Desc *out);
+
+/*::------------------------------------------------------------------::*/
+/* module octree.c */
+int Image_octree_0(Image_Desc *src, Image_Desc *dst);
+int Image_octree_1(Image_Desc *src, Image_Desc *dst);
+
+/*::------------------------------------------------------------------::*/
+/* module pixeliz.c */
+
+/* XXX proto peut-etre pas definitf XXX */
+int Image_pixeliz_0(Image_Desc *src, Image_Desc *dst, int w, int h);
+
+int Image_pixeliz_X(Image_Desc *src, Image_Desc *dst);
+int Image_pixeliz_Y(Image_Desc *src, Image_Desc *dst);
+
+/*::------------------------------------------------------------------::*/
+/* module gray_ops.c
+ *
+ */
+int Image_gray_ops_0(Image_Desc *src, Image_Desc *dst, int k, int mask);
+int Image_gray_ops_1(Image_Desc *src, Image_Desc *dst, int k, int mask);
+
+/*::------------------------------------------------------------------::*/
+/* module classif.c */
+
+typedef struct
+ {
+ int rc, gc, bc;
+ int rad;
+ int r, g, b;
+ } Une_Classe_Sph;
+
+int Image_classif_0(Image_Desc *src, Image_Desc *dst);
+int Image_classif_1(Image_Desc *src, Image_Desc *dst,
+ Une_Classe_Sph *classes, int nbrclasses, int flags);
+int Image_display_classes(Une_Classe_Sph *cla, int nbr, char *txt,
+ int flag);
+
+/*::------------------------------------------------------------------::*/
+/* module effects.c */
+
+int Image_water(Image_Desc *src, Image_Desc *dest, int intensite);
+int Image_noise(Image_Desc *src, Image_Desc *dest, int intensite);
+int Image_mirror(Image_Desc *src, Image_Desc *dest, int reserved);
+int Image_upside_down(Image_Desc *src, Image_Desc *dst, int reserved);
+
+
+int Image_scratch ( Image_Desc *source, Image_Desc * but, long nombre );
+int Image_swap_lines( Image_Desc *src, Image_Desc * dst );
+int Image_swap_cols( Image_Desc *src, Image_Desc * dst );
+int Image_swap_nibbles( Image_Desc *src, Image_Desc * dst );
+
+/* module effects2.c */
+
+int Image_sinwave_0( Image_Desc *source, Image_Desc * but, double *table );
+int Image_sinwave_1( Image_Desc *source, Image_Desc * but, double *table );
+int Image_sinwave_2( Image_Desc *source, Image_Desc * but, double *table );
+int Image_degouline_0(Image_Desc *source, Image_Desc *but, int k1, int k2);
+
+/* module effects3.c */
+int Image_effect_x_0(Image_Desc *s, Image_Desc *d, int kr, int kg, int kb);
+int Image_effect_x_1(Image_Desc *s, Image_Desc *d);
+int Image_effect_x_2(Image_Desc *s, Image_Desc *d, int kx, int ky, int kv);
+int Image_effect_x_3(Image_Desc *s, Image_Desc *d, int kx, int ky, char *comp);
+int Image_effect_x_4(Image_Desc *s, Image_Desc *d, int flags);
+int Image_effect_x_5(Image_Desc *s, Image_Desc *d, int kx, int ky, int kv);
+
+/* module recurse.c */
+
+int Image_call_recursion(Image_Desc *image, Image_Desc *dest, int param);
+int Image_call_recursion_0(Image_Desc *image, Image_Desc *dest, int param);
+
+/*::------------------------------------------------------------------::*/
+/* module television.c
+ */
+int Image_TV_grink(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_TV_grok(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_TV_gruud(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_TV_griiiz(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_TV_old(Image_Desc *src, Image_Desc *dst, int a, int b, int c);
+int Image_TV_veryold(Image_Desc *src, Image_Desc *dst, int a, int b, int c);
+int Image_TV_pix_0(Image_Desc *src, Image_Desc *dst, int w, int h, int grey);
+int Image_TV_pix_1(Image_Desc *src, Image_Desc *dst, int w, int h, int grey);
+
+int Image_TV_cplus_v1(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_TV_triligne(Image_Desc *src, Image_Desc *dst, int p);
+
+/*::------------------------------------------------------------------::*/
+/* module rgbmask.c */
+int Image_rgbmask_H(Image_Desc *src, Image_Desc *dst, int gris);
+int Image_rgbmask_V(Image_Desc *src, Image_Desc *dst, int gris);
+int Image_rgbmask_2(Image_Desc *src, Image_Desc *dst, int gris);
+int Image_rgbmask_R(Image_Desc *src, Image_Desc *dst, int gris);
+
+/*::------------------------------------------------------------------::*/
+/* module mosaic.c
+ *
+ * on va essayer de construire un iterateur de mosaique,
+ * et il faut definir une structure de controle.
+ */
+typedef struct
+ {
+ Image_Desc *src;
+ Image_Desc *dst;
+ int stepx, stepy;
+ int offx, offy;
+ int p1;
+ int p2;
+/* XXX int *func(void *); */
+ } IMAGE_MOSAIC_CTRL;
+/*
+ * vous remarquerez que cette structure est recursive, et
+ * que Gcc grinke feroce dessus...
+ */
+
+int Image_mosaic_0(Image_Desc *src, Image_Desc *dst, int sx, int sy, int flg);
+int Image_mosaic_simple(Image_Desc *src, Image_Desc *dst);
+void Image_mosaic_prctrl(IMAGE_MOSAIC_CTRL *ctrl, char *txt);
+int Image_mosaic_iterateur(IMAGE_MOSAIC_CTRL *ctrl, int yo);
+
+/*::------------------------------------------------------------------::*/
+/* module des vignettes (nex 15 mai 2007) */
+
+int Image_vignetize_x_0(Image_Desc *src, Image_Desc *dst, int prout);
+int Image_vignetize_x_1(Image_Desc *src, Image_Desc *dst, int prout);
+
+/*::------------------------------------------------------------------::*/
+/* module combine.c */
+
+int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ int sy, int oy, int zak);
+int Image_combine_columns(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ int sx, int ox, int zak);
+int Image_combine_checker(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ int sx, int sy, int ox, int oy, int zak);
+int Image_combine_cercle_flou(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int yo);
+int Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int yo, int p1, int p2);
+int Image_combine_minmax(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int flg);
+int Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+int Image_poke_2zones(Image_Desc *src, Image_Desc *ia, Image_Desc *ib,
+ Image_Rect *za, Image_Rect *zb,
+ Image_Desc *dst);
+
+/*::------------------------------------------------------------------::*/
+/* module combine2.c */
+
+int Image_mix(Image_Desc *a, Image_Desc *b, Image_Desc *c, int k);
+int Image_mix_rgb(Image_Desc *a, Image_Desc *b, Image_Desc *c,
+ int kr, int kg, int kb);
+int Image_trimix(Image_Desc *a, Image_Desc *b, Image_Desc *c, Image_Desc *d,
+ char w);
+
+/* module combine3.c */
+int Image_combine_waou(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
+ int a, int b, int c, int d);
+int Image_combine_wauo(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int f);
+int Image_combine_seuils(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
+ int r, int b, int g);
+
+/* module combine4.c */
+int Image_combine_4img_0( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *s3, Image_Desc *s4,
+ Image_Desc *dst);
+int Image_combine_4img_1( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *s3, Image_Desc *s4,
+ Image_Desc *dst);
+int Image_combine_4img_2( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *s3, Image_Desc *s4,
+ Image_Desc *dst, int meth_reduc);
+int Image_combine_4img_2( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *s3, Image_Desc *s4,
+ Image_Desc *dst, int k);
+
+/* module combine5.c */
+int Image_combine_Vdegrade(Image_Desc *, Image_Desc *, Image_Desc *, int);
+int Image_combine_Hdegrade(Image_Desc *, Image_Desc *, Image_Desc *, int);
+int Image_combine_Ddegrade( Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *dst, int sens);
+
+int Image_combine_Vsplit(Image_Desc *, Image_Desc *, Image_Desc *, int, int);
+int Image_combine_Hsplit(Image_Desc *, Image_Desc *, Image_Desc *, int, int);
+
+int Image_combine_stereo_0(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+int Image_combine_stereo_1(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ int kr, int kg, int kb);
+int Image_combine_stereo_2(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
+ char cr, char cl);
+
+
+/* module combine_rnd.c */
+int Image_combine_random_point(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int shift);
+int Image_combine_random_rgb(Image_Desc *s1, Image_Desc *s2,
+ Image_Desc *d, int yop);
+
+/* module combine6.c */
+int Image_combine_power(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+int Image_combine_power_m(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+int Image_XOR(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int notused);
+
+/*::------------------------------------------------------------------::*/
+/* module glitch.c - octobre 2014 */
+
+int Image_GlitchMe(Image_Desc *src, Image_Desc *dst, char code,
+ int k1, char *txt1);
+int Image_Glitch_simple(Image_Desc *src, Image_Desc *dst, int k);
+int Image_Glitch_xor(Image_Desc *src, Image_Desc *dst, int k);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module ascii.c December 2000
+ */
+int Image_ascii_0(Image_Desc *src, char *fname, int largeur);
+int Image_ascii_1(Image_Desc *src, char *fname, int width, char *cars);
+int Image_ascii_2(Image_Desc *src, char *fname, int w, int h, char *c, int f);
+int Image_ascii_3(Image_Desc *src, char *fname, int width, char *cars);
+/*
+ * module asciiart.c December 2000
+ */
+int Image_asciiart_0(Image_Desc *src);
+int Image_asciiart_1(Image_Desc *src, char *pattern, int reverse);
+int Image_asciiart_2(Image_Desc *src, char *pattern, int param);
+
+/*::------------------------------------------------------------------::*/
+/* module calculs.c */
+
+int Image_clamp_pixel(int value);
+
+/* param 'res' is a 8 elements array */
+int Image_minmax_RGB(Image_Desc *img, int *res);
+
+int Image_stats_zone_0(Image_Desc *img, Image_Rect *zone,
+ int *pmr, int *pmg, int *pmb,
+ int *pdr, int *pdg, int *pdb);
+
+int Image_quelques_calculs(Image_Desc *image);
+
+int Image_histo_RGB(Image_Desc *im, long *hr, long *hg, long *hb);
+
+int Image_LUT_RGB(Image_Desc *, Image_Desc *, int *, int *, int *);
+int Image_LUT_mono(Image_Desc *src, Image_Desc *dst, int *lut);
+
+/*::------------------------------------------------------------------::*/
+/* module distances.c */
+
+int Image_distance_0(Image_Desc *ia, Image_Desc *ib,
+ double *dr, double *dg, double *db);
+int Image_distance_1(Image_Desc *ia, Image_Desc *ib,
+ double *dr, double *dg, double *db);
+
+/*::------------------------------------------------------------------::*/
+/* module dissolve.c */
+
+int Image_dissolve_0(Image_Desc *src, Image_Desc *dst, Image_PtList *pts);
+
+/* module photomaton.c */
+int Image_photomaton_0(Image_Desc *src, Image_Desc *dst);
+int Image_photomaton_n(Image_Desc *src, Image_Desc *dst, int nb);
+
+/*::------------------------------------------------------------------::*/
+/* new 14 Jan 2001
+ * module gamma.c
+ */
+int Image_gamma_calcul(double coef, int table[]);
+
+/*::------------------------------------------------------------------::*/
+/* module colors.c */
+
+int Image_swap_colors(Image_Desc *im, char *cols);
+int Image_couleur_moyenne(Image_Desc *im, int *pr, int *pg, int *pb);
+int Image_saturate(Image_Desc *src, Image_Desc *dst, int sr, int sg, int sb);
+int Image_desaturate(Image_Desc *src, Image_Desc *dst, int sr, int sg, int sb);
+
+int Image_color_x(double v1, double v2, int *pr, int *pg, int *pb);
+int Image_RGB_2_HLS(int r, int g, int b, int *ph, int *pl, int *ps);
+
+int Image_colors_recenter_0(Image_Desc *s, Image_Desc *d);
+
+int Image_colors_2_Map(Image_Desc *s, Image_Desc *d, RGB_map * map, int mode);
+
+int Image_to_gray_k(Image_Desc *s, Image_Desc *d,
+ int kr, int kg, int kb, int flag);
+int Image_to_gray(Image_Desc *s, Image_Desc *d, int flag);
+
+int Image_color_shift_rgb(Image_Desc *s, Image_Desc *d, int r, int g, int b);
+
+int Image_apply_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
+int Image_gray_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
+
+int Image_default_RGBA(RGBA *ptr, char *texte, int flags);
+
+/*::------------------------------------------------------------------::*/
+/* module colors2.c */
+
+int Image_AutoSeuilGray(Image_Desc *s, Image_Desc *d, int *ps);
+int Image_BiColor_0(Image_Desc *src, Image_Desc *dst, int k);
+int Image_BiColor_1(Image_Desc *src, Image_Desc *dst, int ka, int kb);
+
+/*::------------------------------------------------------------------::*/
+/* module col_reduc.c
+ */
+int Image_essai_col_reduce(Image_Desc *src, Image_Desc *dst, int n, int p);
+
+/*::------------------------------------------------------------------::*/
+/* module col_xyz.c (new 9 avril 2007) */
+int Image_pix_rgb2xyz_d(int r, int g, int b, double *px, double *py, double *pz);
+
+/*::------------------------------------------------------------------::*/
+/* module col4bits.c
+ */
+int Image_col4bits_and(Image_Desc *src, Image_Desc *dst);
+int Image_calc_Map_4bits(Image_Desc *img, RGB_map *map, int n);
+
+/*::------------------------------------------------------------------::*/
+/* module extractbits.c */
+
+int Image_extrbits_0(Image_Desc *src, Image_Desc *dst, int r, int g, int b);
+
+/*::------------------------------------------------------------------::*/
+/* module ptlist.c
+ */
+int Image_print_point(Image_Point *ppt);
+int Image_ptl_dump(Image_PtList *pl, char *txt);
+Image_PtList *Image_ptl_alloc(int nbre, char *name);
+int Image_ptl_add(Image_PtList *ptl, int x, int y, int h, int c);
+int Image_ptl_write(char *filename, Image_PtList *ptl);
+int Image_ptl_read(char *filename, Image_PtList *ptl);
+int Image_ptl_kill(Image_PtList *ptl, char *msg); /* XXX */
+int Image_ptl_get_size(Image_PtList *ptl, int *nbre, int *avail);
+int Image_ptl_get_point(Image_PtList *ptl, Image_Point *pt, int idx);
+int Image_ptl_boundingbox(Image_PtList *ptl, Image_Rect *box);
+
+/*::------------------------------------------------------------------::*/
+/* module palettes.c */
+
+int Image_load_color_Map(char *file, char *name, RGB_map *where);
+int Image_save_color_Map(char *file, char *name, RGB_map *where);
+
+int Image_attach_Map(Image_Desc *im, char *nom_map, int flags);
+
+int Image_make_random_Map(char *nom, RGB_map *map, int nombre);
+int Image_make_222_Map(char *nom, RGB_map *map, int noise);
+int Image_palette_3sinus(char *nom, RGB_map *ou, double pars[8]);
+
+int Image_mix_palettes(RGB_map *p1, RGB_map *p2, RGB_map *d,
+ char *txt, int k);
+
+int Image_scale_palette(RGB_map *p, double val, int clip_it);
+int Image_scale3_palette(RGB_map *p, double rk, double gk, double bk,
+ int clip_it);
+int Image_map2ppm(RGB_map *p, char *fname, char *comment);
+
+/*::------------------------------------------------------------------::*/
+/* module indexcol.c */
+
+int Image_idxcol_add(Image_Desc *im, int r, int g, int b);
+int Image_idxcol_clear(Image_Desc *im, int flag);
+int Image_idxcol_plot(Image_Desc *im, int x, int y, int c);
+
+/*::------------------------------------------------------------------::*/
+/* module filtres.c */
+
+void Image_filtre_display(FILE *ou, int *mat);
+void Image_rotate_filtre(int *filtre);
+int Image_convolueur3(Image_Desc *in, Image_Desc *out, int *mat);
+int Image_convolueur_2(Image_Desc *in, Image_Desc *out, int *mat, char*pl);
+int Image_raz_sides(Image_Desc *im);
+int Image_lissage_3x3(Image_Desc *in, Image_Desc *out);
+int Image_filtre_Prewitt(Image_Desc *src, Image_Desc *dst, int rot);
+int Image_filtre_Sobel(Image_Desc *src, Image_Desc *dst, int rot);
+int Image_filtre_passe_bas(Image_Desc *src, Image_Desc *dst);
+int Image_filtre_passe_haut(Image_Desc *src, Image_Desc *dst);
+int Image_filtre_random(Image_Desc *src, Image_Desc *dst, int p1, int p2);
+int Image_filtre_random_2(Image_Desc *src, Image_Desc *dst,
+ int p1, int p2, int p3, int p4);
+
+/* module filtadapt.c */
+int Image_filtadapt_0(Image_Desc *src, Image_Desc *dst, int param);
+int Image_filtadapt_1(Image_Desc *src, Image_Desc *dst, int param);
+int Image_filtadapt_2(Image_Desc *src, Image_Desc *dst, int param);
+int Image_filtadapt_3(Image_Desc *src, Image_Desc *dst, int param);
+
+/* module sobel4.c */
+int Image_filtre_Sobel_4(Image_Desc *src, Image_Desc *dst, int rotation);
+
+/*::------------------------------------------------------------------::*/
+/* module morpho.c */
+
+int Image_expand_max(Image_Desc *src, Image_Desc *dst, int factor);
+int Image_expand_min(Image_Desc *src, Image_Desc *dst, int factor);
+int Image_Gray_Sorted_Points(Image_Desc *src, Image_Desc *dst, int *filtre);
+
+/*::------------------------------------------------------------------::*/
+/* module msgsys.c */
+
+char * Image_type2str(int type);
+char * Image_err2str(int codeerr);
+void Image_print_error(char * texte, int err);
+
+/*::------------------------------------------------------------------::*/
+/* module tools.c */
+
+void Image_pacifier(char *texte, int div);
+void Image_pacifier2(char *texte, int cur, int top);
+int Image_start_chrono(char *, int);
+long Image_stop_chrono(char *, int);
+int Image_dump_colormap(RGB_map *map, int verbose_flag);
+int Image_dump_descriptor(Image_Desc *im, char *text);
+int Image_dump_rect(Image_Rect *rect, char *texte, int flag);
+void Image_warning(char caractere, char *lig1, char *lig2, int k);
+int Image_print_rgba(char *txt, RGBA *rgba, int hexa);
+int Image_print_DF3head(DensityF3Head *h, char *txt, int flag);
+int Image_Overlay_Palette(Image_Desc *im, int xo, int yo);
+int Image_fabrique_une_mire(Image_Desc *im, RGB_map *map);
+int Image_Grille(Image_Desc *im, int stepx, int stepy, int rvb);
+int Image_print_minmax(Image_Desc *img);
+int Image_xy_inside(Image_Desc *img, int x, int y);
+
+/*::------------------------------------------------------------------::*/
+/* module marques.c */
+int Image_marque_0(Image_Desc *img, int val);
+int Image_marque_1(Image_Desc *img, char *txt, int flags);
+int Image_marque_2(Image_Desc *img, char *txt, RGBA *rgba, int k1, int k2);
+
+int Image_marque_timestamp(Image_Desc *img, char *txt, RGBA *rgba, int flags);
+int Image_grille(Image_Desc *im, int sx, int ox, int sy, int oy, RGBA *rgba);
+int Image_grille_xor(Image_Desc *i, int sx, int ox, int sy, int oy, RGBA *c);
+
+/*::------------------------------------------------------------------::*/
+/* module mircol.c */
+int Image_mircol_0(Image_Desc *dst, char *txt, int flag);
+int Image_mircol_1(Image_Desc *dst, char *txt, int flag);
+int Image_mircol_2(Image_Desc *dst, char *txt, int flag);
+int Image_mircol_3(Image_Desc *dst, char *txt, int flag);
+int Image_mircol_4(Image_Desc *dst, char *txt, int mode);
+
+int Image_mirRGB_0(Image_Desc *dst, int flag);
+int Image_decompose(Image_Desc *src, Image_Desc *dst, int flag);
+
+/*::------------------------------------------------------------------::*/
+/* module dumppix.c */
+
+int Image_dump_pixels_hexa(char *f, Image_Desc *im, int x, int y, char *t);
+int Image_dump_pixels_ascii(char *fname, Image_Desc *im,
+ int x, int y, int w, int h, int seuil, char canal, char *texte);
+
+/*::------------------------------------------------------------------::*/
+/* module plotteur.c */
+
+int Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte);
+int Image_plot_histo(char *nomtga, long *hr, long *hg, long *hb, char *txt);
+int Image_calc_plot_histo(Image_Desc *img, char *tganame);
+int Image_plot_h_Map(Image_Desc *img, RGB_map *map, int x, int y, int h);
+int Image_plot_v_Map(Image_Desc *img, RGB_map *map, int x, int y, int w);
+int Image_plot_little_h_Map(char *nom, RGB_map *map, char *texte);
+int Image_plot_little_v_Map(char *nom, RGB_map *map, char *texte);
+
+int Image_plot_square_Map(char *fname, RGB_map *map, char *texte, int k);
+int Image_plot_Map(char *nomtga, RGB_map *map , char *txt);
+int Image_plot_histo_hf15(Image_Desc *img, char *nom, char *txt,
+ int p1, int p2);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module gif-op.c
+ * pour celui-la, il faut linker avec gdlib
+ */
+
+int Image_Gif_Overlay(Image_Desc *im, char *nomgif, int x, int y, int t);
+
+/*::------------------------------------------------------------------::*/
+/* module png.c */
+/* new 22 fevrier 2015 - mixart-myrys */
+
+Image_Desc * Image_PNG_alloc_load(char *fname, int k);
+int Image_save_as_PNG(Image_Desc *img, char *fname, int p1, int p2);
+
+/*::------------------------------------------------------------------::*/
+/* module pcx.c */
+int Image_PCX_fileinfo(char *nom);
+int Image_wrPCX_8colors(char *nom, Image_Desc *im);
+int Image_bp2pcx(A_BitPlane *bp, char *fname, int flags);
+
+/*::------------------------------------------------------------------::*/
+/* module pht.c */
+int Image_PHT_save_component(char *name, Image_Desc *img, char color);
+Image_Desc *Image_load_PHT(char *fname);
+
+/*::------------------------------------------------------------------::*/
+/* module pnm.c */
+int Image_wr_pbm_0(char *nom, Image_Desc *im, char channel);
+/* warning: this function was misnamed. */
+int Image_wr_pnm_0(char *nom, Image_Desc *im, int mode);
+/* ... use that instead ... */
+int Image_wr_ppm_0(char *nom, Image_Desc *im, int mode);
+int Image_load_ppm_0(char *name, Image_Desc *ou, int yo);
+int Image_wr_pgm_0(char *nom, Image_Desc *im, char channel);
+
+/*::------------------------------------------------------------------::*/
+/* module bmp.c */
+int Image_BMP_infos(char *nom, int *pw, int *ph, int *pt, int verb);
+Image_Desc * Image_BMP_alloc_load(char *nom, int flag);
+int Image_BMP_save_24(char *filename, Image_Desc *img, int flag);
+
+/*::------------------------------------------------------------------::*/
+/* module tga.c */
+int Image_TGA_save(char *nom, Image_Desc *img, int compress);
+int Image_TGA_save_component(char *nom, Image_Desc *img, char chanl, int comp);
+/* int Image_TGA_print_header(void *ph); XXX */
+int Image_TGA_read_header(FILE *fpin, void *phead);
+int Image_TGA_show_header(char *filename, int flag);
+int Image_TGA_get_dims(char *path, int *pwidth, int *pheight);
+Image_Desc * Image_TGA_alloc_load(char *nom);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module eps.c (new 28 Jan 2002)
+ */
+int Image_EPS_save_0(char *nom, Image_Desc *img);
+
+/*::------------------------------------------------------------------::*/
+/* module des afficheurs sept segments */
+
+int Image_7seg_m0v(Image_Desc *img, int xpos, int ypos, int bits, int k);
+int Image_7seg_digv(Image_Desc *img, int xpos, int ypos, char chiffre, int k);
+int Image_7seg_tag0(Image_Desc *img, char *numstr, int k);
+int Image_7_segments(Image_Desc *img, int nbre, int k);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module dither.c
+ */
+int Image_dither_Bayer_0(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_2x2(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_simple_error(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_seuil_random(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_crude(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_double_seuil(Image_Desc *, Image_Desc *, int, int, int);
+
+/*
+ module dither2.c
+ */
+int Image_dither_3x3_0(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_3x3_1(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_3x3_2(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_3x3_3(Image_Desc *s, Image_Desc *d, int uh);
+
+/* module dither3.c */
+int Image_dither_atkinson(Image_Desc *s, Image_Desc *d, int uh);
+
+/* module dither4.c */
+int Image_dither_4x4_0(Image_Desc *s, Image_Desc *d, int uh);
+int Image_dither_bayer8x8rnd(Image_Desc *s, Image_Desc *d, int uh, int m);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * module textures.c
+ */
+int Image_texture_0(Image_Desc *dst, int bas, int haut);
+int Image_texture_1(Image_Desc *dst, int bas, int haut);
+int Image_texture_2(Image_Desc *dst, int bas, int haut, int modulo);
+int Image_texture_3(Image_Desc *dst, int b, int h, char *ctrl, int qux);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module patterns.c
+ */
+int Image_pattern_000(Image_Desc *img, int foo);
+int Image_pattern_001(Image_Desc *img, int foo);
+int Image_pattern_002(Image_Desc *img, int foo);
+int Image_pattern_003(Image_Desc *img, int foo);
+int Image_pattern_004(Image_Desc *img, int a, int b, int c, int d);
+int Image_pattern_005(Image_Desc *img, RGB_map *map);
+
+int Image_pattern_042(Image_Desc *img, int foo);
+
+/* patterns3.c */
+
+int Image_pattern_100(Image_Desc *dst, int kr, int kg, int kb);
+int Image_pattern_101(Image_Desc *dst, int kr, int kg, int kb);
+int Image_pattern_102(Image_Desc *dst, int par, int kr, int kg, int kb);
+int Image_pattern_103(Image_Desc *dst, int par, int kr, int kg, int kb);
+int Image_pattern_104(Image_Desc *dst, int sx, int sy, RGBA *a, RGBA *b);
+
+/* patterns4.c random noises */
+int Image_gray_noise_0(Image_Desc *dst, int low, int high);
+int Image_rgb_noise_0(Image_Desc *dst, int low, int high);
+int Image_rgba_noise_0(Image_Desc *dst, int low, int high);
+int Image_rgb_noise_1(Image_Desc *dst, RGBA *low, RGBA *high);
+int Image_gray_noise_2(Image_Desc *dst, int low, int high);
+int Image_rgb_noise_2(Image_Desc *dst, RGBA *low, RGBA *high);
+
+int Image_fill_pat_0(Image_Desc *img, Image_Desc *pat, int centered);
+int Image_fill_pat_1(Image_Desc *img, Image_Desc *pat, int centered);
+int Image_fill_pat_2(Image_Desc *img, Image_Desc *pat, int centered);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module bitblt.c Septembre 1999
+ */
+int Image_get_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y);
+int Image_put_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y);
+int Image_copy_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y);
+
+Image_Desc *Image_create_subimg(Image_Desc *src, Image_Rect *r, int gray);
+
+int rc_intersect (const Image_Rect * r1, Image_Rect * r2); /* 2014-01-24 */
+
+/*::------------------------------------------------------------------::*/
+/* module bitplanes.c Mars 2010 */
+
+int Image_dump_BP_head(A_BitPlane *bp, char *txt, int flag);
+A_BitPlane * Image_give_me_a_BP(int largeur, int hauteur);
+int Image_free_that_BP(A_BitPlane *bp, int k); /* new 5 oct 2015 */
+int Image_BP_setname(A_BitPlane *bp, const char *name);
+int Image_BP_clear(A_BitPlane *bp, int bit);
+int Image_BP_plot(A_BitPlane *, int x, int y, int bit);
+int Image_BP_pget(A_BitPlane *bp, int x, int y, int *pbit);
+int Image_BP_to_pbm(A_BitPlane *bp, char *fname, int k);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module op2x2.c 5 Novembre 1999
+ */
+int Image_2x2_contours_0(Image_Desc *);
+int Image_2x2_contours_1(Image_Desc *src, Image_Desc *dst);
+int Image_2x2_contrast(Image_Desc *src, Image_Desc *dst);
+int Image_2x2_lissage(Image_Desc *src, Image_Desc *dst);
+int Image_2x2_rot4pix(Image_Desc *src, Image_Desc *dst, int rot);
+int Image_2x2_shiftUL(Image_Desc *src, Image_Desc *dst);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module de trace de primitives. (drawing.c)
+ */
+int Image_draw_circle(Image_Desc *i, int xc, int yc, int ray, RGBA *q, int m);
+int Image_draw_line(Image_Desc *i, int x1, int y1, int x2, int y2, RGBA *q);
+int Image_paint_rect(Image_Desc *, Image_Rect *, int, int, int);
+int Image_noise_rect(Image_Desc *, Image_Rect *, int, int, int);
+int Image_draw_rect(Image_Desc *, Image_Rect *, int, int, int);
+
+/*
+ * la meme chose, avec le canal alpha (draw_alpha.c)
+ */
+int Image_paint_A_rect(Image_Desc *img, Image_Rect *rect, RGBA *rgba);
+int Image_fade_A_rect(Image_Desc *img, Image_Rect *rect, int alpha);
+int Image_tampon_alpha_0(Image_Desc *s, Image_Desc *tampon, Image_Desc *d);
+
+/*
+ * same things with patterns.
+ */
+int Image_draw_rect_from_patt(Image_Desc *img, Image_Rect *rect,
+ Image_Desc *patt);
+
+/*::------------------------------------------------------------------::*/
+/* module pov_hf15.c */
+int Image_hf15_plot(Image_Desc *im, int x, int y, int h);
+int Image_hf15_height(Image_Desc *im, int x, int y);
+int Image_hf15_hf2gray(Image_Desc *src, Image_Desc *dst, int mode);
+int Image_hf15_rgb2hf(Image_Desc *src, Image_Desc *dst, int mode);
+int Image_hf15_save_PGM(char *nom, Image_Desc *img, char *comment);
+int Image_hf15_lissage(Image_Desc *s, Image_Desc *d, int coef, int flag);
+int Image_hf15_calc_minmax(Image_Desc *img, char *txt, int *pmin, int *pmax);
+int Image_hf15_mul_add(Image_Desc *src, Image_Desc *dst, int mul, int add);
+int Image_hf15_invert(Image_Desc *src, Image_Desc *dst);
+int Image_hf15_sweep(Image_Desc *im, int hfin, int taille, int reserved);
+int Image_hf15_getmin(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+int Image_hf15_getmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
+
+/* module pov_hf15b.c */
+int Image_hf15_normalize(Image_Desc *src, Image_Desc *dst, int low, int high);
+int Image_hf15_make_colmap_0(Image_Desc *src, Image_Desc *dst, char *mapname);
+int Image_hf15_make_colmap_1(Image_Desc *src, Image_Desc *dst, RGB_map *map);
+
+/* module pov_hf15c.c */
+
+int Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int k);
+int Image_hf15_mult_2(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
+int Image_hf15_div(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
+int Image_hf15_sqrt(Image_Desc *src, Image_Desc *dst);
+int Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double pow4a);
+int Image_hf15_exp1(Image_Desc *src, Image_Desc *dst);
+int Image_hf15_exp2(Image_Desc *src, Image_Desc *dst);
+
+/* module pov_hf15d.c */
+int Image_hf15_noise_0(Image_Desc *dst, int low, int high, int prob100);
+int Image_hf15_noise_1(Image_Desc *dst, int low, int high, int prob100);
+int Image_hf15_noise_2(Image_Desc *dst, int lo, int hi, int k1, int k2);
+int Image_hf15_noise_3(Image_Desc *dst, double coef, int flag);
+
+/* module pov_hf15d.c */
+int Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef);
+int Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef);
+
+/* module pov_hf_synth.c */
+int Image_hf15_synth_0(Image_Desc *dst, Image_PtList *ptl);
+int Image_hf15_synth_1(Image_Desc *dst, Image_PtList *ptl);
+int Image_hf15_synth_fromfunc0(Image_Desc *dst, int param,
+ double(*func)(int x, int y, int p));
+
+/*::------------------------------------------------------------------::*/
+/* nouveau. d'apres la doc de povray 3.1 ymmv */
+
+DensityF3Head * Image_df3_alloc(char *nom, int x, int y, int z, int b);
+int Image_df3_free(DensityF3Head *ptr);
+int Image_df3_set_bytes(DensityF3Head *ptr, int nbb);
+int Image_df3_set_scale(DensityF3Head *ptr, double scale);
+
+int Image_df3_put(DensityF3Head *ptr, int x, int y, int z, double dv);
+int Image_df3_get(DensityF3Head *ptr, int x, int y, int z, double *pdv);
+
+int Image_df3f_get_dims(char *fname, int dims[], int display);
+int Image_df3f_explique(char *fname);
+int Image_df3_export(DensityF3Head *ptr, char *fname, int nbbytes);
+
+/* fonctions en vrac de df3b.c */
+int Image_df3_xper_0(Image_Desc *src, char * fname_df3, int k);
+int Image_df3f_plot_histo(char *fname_df3, char *nomtga, int flag);
+int Image_df3f_2_txt(char *nomfd3, char *nomtxt);
+
+int Image_df3f_2_povinc(char *nomdf3, char *nominc, char *nomobj, int k,
+ double dv);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module detect.c
+ */
+int Image_detect_tops(Image_Desc *src, Image_Desc *dst, int flags);
+int Image_detect_flat_gray(Image_Desc *, Image_Desc *, int, int);
+int Image_correlator_0(Image_Desc *src, Image_Desc *dst, int matrice[]);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module detect2.c
+ */
+int Image_pix2ptl(Image_Desc *img, int seuil, Image_PtList *ptl);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module cadres.c new 24 Jan 2000
+ */
+int Image_cadre_A(Image_Desc *im);
+int Image_cadre_B(Image_Desc *im, int larg);
+int Image_cadre_cracra(Image_Desc *im, int larg, int k);
+int Image_cadre_C(Image_Desc *, int, int, int, int);
+int Image_cadre_bruit(Image_Desc *, int, int, int, int);
+int Image_cadre_E(Image_Desc *, int, int, int, int);
+
+int Image_cadre_pattern_0(Image_Desc *, Image_Desc *, int);
+int Image_cadre_pattern_1(Image_Desc *im, Image_Desc *pat, int n);
+int Image_cadre_pattern_2(Image_Desc *im, Image_Desc *pat, int n);
+
+/* module cadres2.c */
+
+int
+Image_cadre2_soft_1(Image_Desc *src, Image_Desc *dst, RGBA *fond, RGBA *cadre,
+ int larg, int v1, int v2, int v3, int v4);
+
+int Image_cadre2_pixx(Image_Desc *src, Image_Desc *dst, int p1, int p2);
+int Image_cadre_f(Image_Desc *im, int a, int b);
+
+/* module cadres3.c */
+
+int Image_cadre_waves_0(Image_Desc *img, int perx, int pery,
+ RGBA *rgb, int amp);
+int Image_cadre_waves_1(Image_Desc *img, int perx, int pery,
+ RGBA *rgb, int amp);
+int Image_cadre_waves_2(Image_Desc *img, int perx, int pery, int amp);
+
+/* module cadres4.c */
+
+int Image_cadre_burp_0(Image_Desc *img, int p1, int p2, int flags);
+int Image_cadre_burp_1(Image_Desc *img, int p1, int p2, int flags);
+int Image_cadre_burp_2(Image_Desc *img, int t, int pr, int pg, int pb);
+int Image_cadre_burp_3(Image_Desc *img, int t, int pr, int pg, int pb);
+int Image_cadre_rasta_0(Image_Desc *img, int foo);
+
+/* module cadre84.c */
+
+int Image_cadre_b84_a(Image_Desc *img, int px, int py, int k);
+int Image_cadre_b84_b(Image_Desc *img, int foo, int k1);
+int Image_cadre_b84_c(Image_Desc *img, int foo, int k1, int k2);
+
+/* module cadresbox.c new janvier 2014 */
+int Image_cadre_box_0(Image_Desc *img, int t1, RGBA *color);
+int Image_cadre_4coins_0(Image_Desc *img, int taille, RGBA *color);
+int Image_cadre_box4c_0(Image_Desc *img, int t1, int t2, RGBA *color);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module alpha.c new 31 Jan 2000
+ operations sur les transparences
+ */
+int Image_RGBA_over_RGB(Image_Desc *a, Image_Desc *src, Image_Desc *dst);
+int Image_add_alpha_channel(Image_Desc *img, int value);
+int Image_kill_alpha_channel(Image_Desc *img);
+int Image_map_alpha_on_img(Image_Desc *img);
+int Image_alpha_op_0(Image_Desc *src, Image_Desc *dst, int v1, int v2,
+ int rb, int rt, int gb, int gt, int bb, int bt, int par);
+int Image_copy_component_to_alpha(Image_Desc *img, char component);
+
+int Image_alpha_reduce(Image_Desc *src, Image_Desc *dst, int yo);
+int Image_poke_alpha_from_rgb(Image_Desc *src, Image_Desc *dst,
+ int r, int g, int b, int flag);
+
+/* module alpha2.c */
+
+int Image_alpha_setvalue(Image_Desc *, int v_alpha);
+int Image_alpha_pattern_0(Image_Desc *, Image_Desc *, Image_Desc *);
+int Image_alpha_pattern_1(Image_Desc *, Image_Desc *, Image_Desc *);
+
+/*::------------------------------------------------------------------::*/
+/* module insert.c */
+int Image_insert_with_alpha(Image_Desc *img, Image_Desc *ins, int foo);
+
+/*::------------------------------------------------------------------::*/
+/* module contrast.c new: dec 2013 */
+
+int Image_pix_square(Image_Desc *source, Image_Desc *but, int k);
+int Image_pix_sqroot(Image_Desc *source, Image_Desc *but, int k);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module levels.c new: Jan 2001
+ */
+int Image_level_0(Image_Desc *, Image_Desc *, int);
+
+/*::------------------------------------------------------------------::*/
+/*
+ module calcluts.c
+*/
+int Image_calclut_lin(int *lut, int v0, int v255);
+int Image_calclut_foo(int *lut, int v0, int v255);
+int Image_print_lut(int *lut, char *fname, int flag);
+int Image_load_lut(int *lut, char *fname, int flag);
+
+/* module luts15bits.c (new avril 2008) */
+
+int Image_lut15_fill_0(int r[32768], int *g, int *b);
+int Image_lut15_fill_1(int *r, int *g, int *b);
+int Image_lut15_essai(char *hfname, char *tganame, int ka);
+/*::------------------------------------------------------------------::*/
+/* scale.c */
+int Image_scale_simple(Image_Desc *src, Image_Desc *dst, int k);
+int Image_scale_bilinear(Image_Desc *src, Image_Desc *dst, int k);
+int Image_getpix_bilin(Image_Desc *src, double fx, double fy,
+ int *pr, int *pg, int *pb);
+Image_Desc * Image_new_scale( Image_Desc *, float, float, int );
+
+/* halfsize.c */
+Image_Desc * Image_MakeHalfSize(Image_Desc *image, int methode);
+
+/* doublesz.c */
+Image_Desc * Image_MakeDoubleSize(Image_Desc *image, int methode);
+Image_Desc * Image_MakeDoubleSize_H(Image_Desc *image, int methode);
+
+/*::------------------------------------------------------------------::*/
+/* addborder.c */
+
+int Image_ReAllocate(Image_Desc *img, int neww, int newh);
+
+/*::------------------------------------------------------------------::*/
+/* showdiff.c */
+
+int Image_showdiff_0(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst);
+int Image_showdiff_1(Image_Desc *i1, Image_Desc *i2, Image_Desc *d, int nu);
+int Image_showdiff_2(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst,
+ int dmin);
+int Image_showdiff_3(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst,
+ int kr, int kg, int kb);
+
+/*::------------------------------------------------------------------::*/
+/* text0.c */
+
+int Image_load_fnt8x8(char *nomfnt, uint8_t *ou, int flags);
+int Image_trace_caractere(Image_Desc *im, int x, int y, int code);
+int Image_trace_caractere_2(Image_Desc *im, uint8_t *fnt, int x, int y,
+ int code, RGBA *paper, RGBA *ink);
+
+int Image_trace_chaine_0(Image_Desc *im, char *txt, int x, int y,
+ RGBA *paper, RGBA *ink, int flags);
+int Image_trace_chaine_1(Image_Desc *im, char *txt, int x, int y,
+ char *nomfonte, RGBA *paper, RGBA *ink);
+
+int Image_trace_big_char_0(Image_Desc *im, int x, int y, int c, int kx, int ky);
+
+/* text1.c */
+int Image_txt1_box_0(Image_Desc *img, char *txt, int x, int y, int w,
+ RGBA *paper, RGBA *ink, int flags);
+int Image_txt1_big_0(Image_Desc *im, char *txt, int x, int y, int xf, int yf);
+
+/* text2.c */
+int Image_texte_fonte(char *nomfonte, char *nomtga);
+
+/* text16x24.c */
+int Image_t16x24_binload(char *fontname, uint8_t *zone, int flag);
+int Image_t16x24_txtload(char *fontname, uint8_t *zone, int flag);
+int Image_t16x24_pltch_exp(Image_Desc *img, int lettre, int x, int y);
+int Image_t16x24_pltch_1(Image_Desc *img, int lettre, int x, int y,
+ RGBA *pap, RGBA *ink, int flags);
+int Image_t16x24_pltstr_1(Image_Desc *img, char *str, int x, int y,
+ RGBA *paper, RGBA *ink, int flags);
+int Image_t16x24_essai(char *fontname, char *texte, char *tganame);
+int Image_t16x24_chars_map(char *fontname, char *tganame, int flag);
+
+/*::------------------------------------------------------------------::*/
+/* vectfont.c */
+
+int Image_vectfont_init(char *fontname);
+int Image_vectfont_char_0(Image_Desc *im, char ch, int x, int y,
+ int r, int g, int b);
+int Image_vectfont_text_0(Image_Desc *im, char *txt, int x, int y);
+
+/*::------------------------------------------------------------------::*/
+/*
+ warpeurs: deformation d'image
+*/
+
+int Image_warp_essai_0(Image_Desc *src, Image_Desc *dst, double angle,
+ int xc, int yc);
+int Image_warp_essai_1(Image_Desc *src, Image_Desc *dst, double angle);
+
+/*::------------------------------------------------------------------::*/
+int Image_center_rotate(Image_Desc *src, Image_Desc *dst, double angle);
+
+/*::------------------------------------------------------------------::*/
+
+int Image_shift_xy(Image_Desc *src, Image_Desc *dst, int ox, int oy);
+int Image_shift_x(Image_Desc *src, Image_Desc *dst, int ox);
+int Image_shift_y(Image_Desc *src, Image_Desc *dst, int oy);
+int Image_center_rotate_xy(Image_Desc *src, Image_Desc *dst, double angle,
+ double x, double y);
+
+/*::------------------------------------------------------------------::*/
+
+int Image_interpolate_0(Image_Desc *src, Image_Desc *dst, int ox, int oy);
+int Image_interpolate_1(Image_Desc *src, Image_Desc *dst, int ox, int oy);
+int Image_interpolate_2(Image_Desc *src, Image_Desc *dst, RGBA *rgba);
+
+/*::------------------------------------------------------------------::*/
+/* anamorphose.c */
+
+int Image_anmo_X(Image_Desc *src, Image_Desc *dst);
+int Image_anmo_grille(Image_Desc *dst);
+int Image_anmo_essai_0(char *nomtga, int w, int h, int flgtxt);
+
+/*::------------------------------------------------------------------::*/
+/* fits.c
+ format de fichier utilise par les astronomes */
+
+int Image_fits_print_fileinfo(char *filename, int flags);
+
+/*::------------------------------------------------------------------::*/
+/* troisD.c */
+
+int Image_3d_infos(Image_Desc *img, int flags);
+
+/*::------------------------------------------------------------------::*/
+/* tortue.c */
+
+int Image_turtle_infos(Image_Desc *img, int flags);
+int Image_turtle_setcolors(Image_Desc *img, int r, int g, int b);
+int Image_turtle_move(Image_Desc *img, double xt, double yt);
+int Image_turtle_draw(Image_Desc *img, double xt, double yt);
+
+/*::------------------------------------------------------------------::*/
+/* calling 'cjpeg' */
+int Image_system_cjpeg(Image_Desc *img, char *filename, int quality);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * gestion de pools d'images - new 21 mars 2007
+ */
+
+void Image_Pool_infos(int flag);
+void * Image_Pool_create(char *name, int nbre, int width, int height);
+int Image_Pool_describe(void *ptr, char *text, int flags);
+int Image_Pool_destroy(void *ptr, char *text, int flags);
+
+/*::------------------------------------------------------------------::*/
+/* quadpics.c - nouveau juillet 2014 a mixart-myrys */
+
+int Image_quadsym_simple(Image_Desc *src, Image_Desc *dst, int mode);
+
+/*::------------------------------------------------------------------::*/
+int Image_essai_zoom(Image_Desc *src, Image_Desc *dst,
+ double kx, double ky, int flags);
+/*::------------------------------------------------------------------::*/
+/* imprime.c */
+
+int Image_print_histo_0(long *histo, char *fname, char *txt);
+void Image_print_sizeof_structs(char *texte);
+
+/*::------------------------------------------------------------------::*/
+int Image_gadrct_premier_essai(Image_Desc *src, Image_Rect *rect,
+ Image_Desc *dst, int ka, int kb);
+int Image_gadrct_Hsweep_0(Image_Desc *dst, Image_Rect *rect, int flag);
+int Image_gadrct_Vsweep_0(Image_Desc *dst, Image_Rect *rect, int flag);
+int Image_gadrct_poke_from_tga(char *namesrc, Image_Rect *fromrect,
+ Image_Desc *dst, int xdst, int ydst, int flags);
+int Image_gadrct_to_gray(Image_Desc *src, Image_Rect *rect,
+ Image_Desc *dst, int ka, int kb);
+int Image_gadrct_dimmer(Image_Desc *img, Image_Rect *rect, float dimf);
+int Image_gadrct_cross(Image_Desc *img, Image_Rect *rect, int k);
+
+/*::------------------------------------------------------------------::*/
+/*
+ * #endif du test anti-double-inclusion de la-bas,
+ * tout en haut du fichier...
+ */
+#endif
+
