tTh/libtthimage
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

hop, le premier bug

Browse Source
This commit is contained in:
tth 2022-06-26 02:23:53 +02:00
parent fc17a4c260
commit e795f8a5bf
36 changed files with 6055 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

321
Doc/image77.html Normal file
View File

@ -0,0 +1,321 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: la doc de l'interface Fortran</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, image77, Boudet, Fortran, F77, g77">
</head>
<body>
<a name="top"><h1>libimage et fortran</h1></a>
<p align=center>
<tt>dernière mise à jour: 26 juin 2022</tt><br>
</p>
<hr>
<h3>
Le FORTRAN77 est définitivement perdu, du moins la version <i>GNU</i>
n'est plus maintenue. Il est donc temps de passer au Fortran Moderne.
</h3>
<hr>
<p class=explique">
Voici la description de l'interface de l'ancien système.
Le couplage avec <tt>gfortran</tt> sera assez semblable.
</p>
<h2><a name="primitives">primitives</a></h2>
<dl class="proto">
<dt>SLOT = IMG_CREATE(WIDTH, HEIGHT, 3)
<dd> Création d'une nouvelle image de type RGB en mémoire.
<dt>NEWSLOT = IMG_CLONE(SLOT)
<dd> Création d'une copie en mémoire d'une image existante.
<dt>CALL IMG_FREE(SLOT)
<dd> Destruction d'une image. Il est convenant de ne plus utiliser son
<i>numéro de slot</i> après cette opération.
<dt>CALL IMG_CLEAR(SLOT, RED, GREEN, BLUE)
<dd> Remplissage d'une image avec les valeurs RGB entre 0 et 255.
<dt>CALL IMG_DIMS(SLOT, WIDTH, HEIGHT)
<dd> Récupération des dimensions d'une image.
</dl>
<h2><a name="io">input/output</a></h2>
<p>Je vous préviens d'entrée, les problèmes de <i>BOUTISME</i> sont
loin d'être réglés. Donc pour le moment, ça ne marche bien <i>QUE</i> sur
des processeurs de type <i>386</i>.
Pour les <font color="#8080ff">Sparcs</font> c'est en bonne voie. A vous
d'essayer, et de me raconter ça...
</p>
<dl class="proto">
<dt>PIC = TGA_ALOAD(NOM, W, H, T)
<dd>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.
<dt>FOO = TGA_SAVE_N(SLOT, NUMBER)
<dd>Sauvegarde du SLOT au format TGA sous un nom de fichier de la forme
<tt>im_nnnnn.tga</tt>. <i>exemple: NUMBER=42 donne 'im_00042.tga'</i>.
Le nombre de '0' de tête étant à vérifier,
<a href="img-devel.html">utsl</a>.
<dt>FOO = IMG_PPM_SA(SLOT, NOM, 0)
<dd> Enregistrement au format
<a href="img-fichiers.html#pnm">portable pixmap</a> en mode ascii. Attention,
les fichiers sont <i>très</i> gros. Par contre, ils sont très facile à lire
sur toutes les plateformes. <font color="red">fonction pas trop testée</font>.
<dt>FOO = IMG_TGA_SA(SLOT, NOM, 0)
<dd> 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.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="utilitaires">utilitaires</a></h2>
<dl class="proto">
<dt>call img_version(flag)<br>
<dd>Affiche la version de la librairie sur <i>stdout</i>. Si le <small>FLAG</small>
est différent de 0, infos supplémentaires.
<dt>call img_dumpslots(flag)<br>
<dd>Une liste des images actuellement déclarées. <small>FLAG</small> à 1 donne plus
d'informations.
</dl>
<hr>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="effets">effets</a></h2>
<p>Je ne vais pas m'étendre sur les effets disponibles. Il y a plus de docs
<a href="img-effets.html">ici</a> où
<a href="img-effets.html#effets2">là</a>. 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).
</p>
<p>
Quelques effets expérimentaux sont arrivés en Janvier 2003. Le source de
l'interface est <tt>img77x.c</tt> et vous trouverez dedans bien plus de
détails que ce que je ne peux en donner ici.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="bruits">Générateurs de bruit</a></h2>
<p>
Attention, la rigueur mathématique de ces fonctions <b>n</b>'est <b>pas</b>
garantie. Avant de critiquer, <a href="img-devel.html#utsl">Utsl</a>.
</p>
<ul>
<li><tt>call img_grayrnd0(slot, bas, haut)</tt>
<li><tt>call img_rgbrnd0(slot, bas, haut)</tt>
<li><tt>call img_rgbrnd1(slot, br, bv, bb, hr, hv, hb)</tt>
<li><tt>call img_grayrnd2(slot, bas, haut)</tt>
</ul>
<p>
Dans le fichier <tt>funcs77.f</tt>, vous trouverez une fonction de démonstration
des générateurs de bruit.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="recopies">Recopie d'images</a></h2>
<p>
Attention, ces fonctions ne sont pas blindées, il y a de fortes probabilités
de <i>coredump</i> si les paramètres passés sont incohérents.
</p>
<dl class="proto">
</dl>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="textes">Ecriture de textes</a></h2>
<p>
Là aussi c'est un peu brouillon, j'ai rajouté ça rapidement
alors que je travaillais sur le
<a href="http://tontonth.free.fr/recuit/cuisson-fmbl.html">recuit simulé</a>.
En fait, c'est un domaine assez vaste, et qui n'est pas trop normalisé dans
les systèmes Unix. Donc, je <a href="img-texte.html">bricole</a>, et je ne
construit rien de vraiment concret.
</p>
<dl class="proto">
<dt>Houba ? <dd>Hop !
<dt>call img_txt_0(numimg, texte, x, y, mode)
<dd>Le plus tortueux des paramètres, c'est <tt>mode</tt>, qui peut prendre
plusieurs valeurs non documentées.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="povray">POVray</a></h2>
<p>
<a href="http://www.povray.org/">POVray</a> est un <i>ray-tracer</i> qui
peut utiliser des <i>height_fields</i>, c'est à dire des matrices à deux
dimensions dont chaque élément <a href="img-povhf15.html">représente</a> une
altitude.
</p>
<dl class="proto">
<dt>img_hf_plot (img, x, y, h)
<dd>Ecriture de l'altitude d'un point. L'altitude est un entier compris
entre 0 et 32767. Le clipping est mal géré.
<dt>h = img_hf_height (img, x, y)
<dd>Lecture de l'altitude d'un point. Une valeur négative indique à coup
sûr une erreur.
<dt>img_hf_add (image, x, y, valeur)
<dd>Ajoute <tt>valeur</tt> à l'altitude du point x,y. L'altitude résultante sera
automagiquement bornée entre 0 et 32767.
<dt>img_hf_smooth(src, dst, k)
<dd>Lissage d'une image. <tt>K</tt> permet de régler la force de l'action, et
c'est expliqué <a href="img-povhf15.html#traitements">là</a>.
<dt>img_hf_noise3(img, coef, flag)
<dd>Bruitage d'une image, proportionnellement à l'altitude. Le <tt>coef</tt>
doit être un <i>double precision</i>. <tt>flag</tt> n'est pas utilisé, donc
il faut mettre 0.
</dl>
<p>
Pour sauvegarder un height-field généré depuis le Fortran, on utilisera
les fonctions <a href="#io">classiques</a> d'enregistrement
de fichiers Targa.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="fonctions">fonctions</a></h2>
<dl class="proto">
<dt>call img_mix0(numsrc1, numsrc2, numdst, float_coef)
<dd>Mix of the two source pictures in the destination. The coefficient
is a <tt>float</tt> between 0.0 and 1.0 but you can try others
values...
</dl>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="cadres">cadres</a></h2>
<dl class="proto">
<dt>call img_cadre(numimage, type)
<dd>
<i>type</i> est un entier donnant le numéro du cadre. Pour ceux qui veulent
une correspondance, il faut chercher dans <tt>img77a.c</tt>.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="bitplane">bitplane</a></h2>
<p>
Mmmmm... Pas de code Fortran écrit, mais déja un peu de
<a href="img-bitplane.html">documentation</a> de quelques primitives en C.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="calculs">Calculs</a></h2>
<p>Certaines de ces choses devraient plutôt être vues comme
des <a href="#fonctions">fonctions</a>. Ce n'est pas si simple.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="patterns">Patterns</a></h2>
<a href="img-patterns.html">Mmmmm</a>...
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="exemples">exemples</a></h2>
<p> Dans le <a href="libimage.tar.gz">tarball</a> vous
trouverez un <tt>demo77.f</tt> et un <tt>funcs.f</tt> qui pourront vous
servir de base de départ. Mais pour voir tout de suite de quoi il
s'agit : </p>
<pre class="code">
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
</pre>
<p>
<a href="http://tontonth.free.fr/pov/hf/">Ici</a>, 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.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<ul>
<li>Sur la plupart des systèmes libres, on utilise le compilateur
<a href="http://gcc.gnu.org/">g77</a>. Et même sur des systèmes <i>non</i>
libres, d'ailleurs...</li>
<li>On peut aussi écrire des
<a href="http://krabulator.free.fr/devel/cgi77.html">CGI</a> avec g77.
Mais je n'ai pas encore testé une combinaison de cgi77 et libimage. </li>
<li>Une alternative digne d'interet est <b>PGPLOT</b> pour dessiner
en Fortran. Votre <a href="http://www.google.com/">g00gl3</a> favori
vous trouvera le lien kivabien.</li>
<li>Je travaille de temps en temps sur quelques traitements de
"haut niveau" en Fortran77, c'est un peu du
<a href="http://tboudet.free.fr/libimage/imagerie77.tar.gz">code</a>
intérimaire, puisque une migration vers <b>gfortran</b> est en
préparation.
</li>
<li>Depuis quelques jours, j'ai ouvert un
<a href="http://fortran.morefun.over-blog.com/">blog</a> pour vous
raconter mon utilisation <i>alternative</i> de ce langage d'un autre
siècle.</li>
</ul>
<p class="footer">
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est sur carte perforée, je patche à donf.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

94
Doc/img-alpha.html Normal file
View File

@ -0,0 +1,94 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: le canal alpha</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, alpha, transparency, alpha mask, alphachannel">
</head>
<body>
<h1><a name="top">libimage / le canal alpha</a></h1>
<p align=center>
<tt>dernière mise à jour: 25 octobre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#liens">liens</a>]
[<a href="img-devel.html#contribuer">contribuer</a>]
</p>
<p>
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 :)
</p>
<p>
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 <i>alpha</i>: la valeur 255
est-elle transparence absolue, ou pas de transparence du tout ?
</p>
<dl class="proto">
<dt>int Image_add_alpha_channel(Image_Desc *img, int value);
<dd>Rajoute un plan 'alpha' non initialisé a une image de type RGB. Retourne
le <a href="img-devel.html#return">code d'erreur</a> VERY_STRANGE si il y a
déja un canal alpha.
<dt>int Image_kill_alpha_channel(Image_Desc *img);
<dd>Détruit un éventuel canal 'alpha' ou retourne VERY_STRANGE en cas de
doute ou d'incertitude.
<dt>int Image_RGBA_over_RGB(Image_Desc *rgba, Image_Desc *src,
Image_Desc *dst);
<dd>Pour voir cette fonction en service, vous devez aller fouiller dans les
sources de <i>Debian vs. eEmpire</i>, plus précisement dans <i>finisher.c</i>.
<dt>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);
<dd>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.<br>
C'est clair, non ?
<dt>Image_alpha_reduce(Image_Desc *src, Image_Dest *dst, int yo);
<dd>Pour chaque pixel, les valeurs r, g et b sont mises à l'échelle par
la valeur alpha du pixel.
<dt>int Image_poke_alpha_from_rgb(Image_Desc *src, Image_Desc *dst,
int fr, int fg, int fb, int flag);
<dd>
</dl>
<p>
Vous constaterez, à la lecture des lignes précédentes, que je ne sais
pas encore bien gérer la transparence.
</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<tt><b>TROLL</b>: pour l'Alpha, le mieux, c'est
<a href="http://www.digital.com/">DEC</a></tt>
<p align=right><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter
<a href="http://tboudet.free.fr/cv.html">par là</a><br>
Votre demande est transparente: je pense avant de coder.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

70
Doc/img-asciiart.html Normal file
View File

@ -0,0 +1,70 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: AsciiArt p0w4</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, ascii-art, operations">
</head>
<body>
<a name="top"><h1>libimage / AsciiArt p0w4</h1></a>
<p align=center>
<tt>dernière mise à jour: 4 novembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-texte.html">textes</a>]
</p>
<p class="explique">
Attention, ceci est un <i>work in progress</i>. L'interface de certaines
fonctions n'est pas encore stabilisée. On peut même dire que ce n'est
pas utilisable.
</p>
<p>
Pour les curieux, il y a quand même un programme de test: <tt>t_ascii.c</tt>
dans le <a href="libimage.tar.gz">tarball</a> qui contient quelques
informations. Il convient également de rappeler que les résultats que
vous obtiendrez sont <b>très</b> dépendants de l'image d'origine.
</p>
<a name="levels"><h2>ascii</h2></a>
<p>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 <tt>libcaca</tt> du
génial <a href="http://sam.zoy.org/">Sam</a>.
</p>
<dl class="proto">
<dt>int Image_ascii_0(Image_Desc *src, char *fname, int largeur);
<dd>
<dt>int Image_ascii_1(Image_Desc *src, char *nom, int width, char *cars);
<dd>
</dl>
<a name="contours"><h2>ascii art</h2></a>
<p>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.
</p>
<dl class="proto">
<dt> int Image_asciiart_1(Image_Desc *src, char *pattern, int reverse);
<dd>Oups, mais cette fonction semble fonctionner :)<br>
Le paramètre pattern est une chaine de caractères du genre
<tt>&amp; .o*O&amp;</tt> qui va représenter les différents niveaux de gris.
</dl>
<p class="footer">
<b>tTh</b>, newbie en ascii-art depuis 1982<br>
<a href="#top">haut de page</a></p>
</body>
</html>

108
Doc/img-bitplane.html Normal file
View File

@ -0,0 +1,108 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les plans de bits</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, dinorama, plans de bits">
</head>
<body>
<h1>libimage: les plans de bits</h1>
<p align=center>
<tt>dernière mise à jour: 5 avril 2014</tt><br>
</p>
<p>
Une image que j'appelle parfois <i>bitplane</i>, parfois <i>plan de bits</i>,
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 <i>rgb8</i> est associée, et ces deux teintes seront
utilisables par les routines de sauvegarde de ces images.
</p>
<p>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 <i>opaque</i> :
</p>
<pre>
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 */
</pre>
<p>Il est possible qu'il existe des contraintes sur les dimensions
du bitplane. Utsl.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="creation">creation</a></h2>
<p>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.
</p>
<dl class="proto">
<dt>A_BitPlane * Image_give_me_a_BP(int width, int height);
<dd>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 <i>dddd</i>) cohérentes pour la suite
des opérations.
<dt>int Image_BP_setname(A_BitPlane *bp, char *name);
<dd>Attribue un nom (d'une longueur inférieure à <tt>IMG_OBJNAME_LEN</tt>)
à un bitplane. Ce nom pourra être éventuellement inscrit sur l'image
sauvegardée dans un <a href="img-fichiers.html#pcx">fichier</a>.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="utilisation">utilisation</a></h2>
<dl class="proto">
<dt>int Image_BP_clear(A_BitPlane *bp, int bit);
<dd>Effacement, remise à <tt>bit</tt> d'une bitplane.
<dt>int Image_BP_plot(A_BitPlane *bp, int x, int y, int bit);
<dd>Positionnement d'un bit dans le bitplane. Attention, <tt>bit</tt>
doit avoir 0 ou 1 comme valeur.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="fichier">fichier</a></h2>
<dl class="proto">
<dt>int Image_BP_savepcx(A_BitPlane *bp, char *filename, int flag);
<dd>Enregistrement en PCX monochrome. Ne fonctionne pas encore.
<dt>int Image_BP_to_pbm(A_BitPlane *bp, char *fname, int k);
<dd>Enregistrement en portable bit map non compressé. La relecture
est pour bientôt.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2>Et ensuite ?</h2>
<p>
Vous en savez assez maintenant. Vous pouvez expérimenter en attendant
l'arrivée de <a href="image77.html#bitplane">l'interface Fortran</a>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
</body>
</html>

111
Doc/img-cadres.html Normal file
View File

@ -0,0 +1,111 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: comment faire des cadres</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, cadres, encadrement">
</head>
<body>
<h1><a name="top">libimage / comment faire des cadres</a></h1>
<p align=center>
<tt>dernière mise à jour: 28 janvier 2014</tt><br>
</p>
<p>
Bon, pas grand chose à dire, là sur le coup. La commande
<a href="img-outils.html#cadre">tga_cadre</a> 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...
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="#liens">liens</a>]
</p>
<dl class="proto">
<dt>int Image_cadre_A(Image_Desc *im);
<dd>Juste un cadre simple: un petit filet blanc autour de l'image.
<dt>int Image_cadre_cracra(Image_Desc *im, int largeur, int reserved);
<dd>Une sorte de machin bizarre, qui remplace l'ancienne fonction
<tt>Image_cadre_B</tt>. le troisième paramêtre n'est pas encore
utilisé. Voir aussi <tt>Image_cadre_U</tt> pour un truc aussi <i><b>U</b>gly</i>.
<dt>int Image_cadre_C(Image_Desc *im, int r, int g, int b, int n);
<dd>En fonction de la distance <b>n</b> du bord de l'image, un dégradé entre
la teinte (r,g,b) et la valeur du pixel.
<dt>int Image_cadre_bruit(Image_Desc *im, int r, int g, int b, int n);
<dd>Proportionnellement à la distance <b>n</b> 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.
<dt>int Image_cadre_E(Image_Desc *im, int r, int g, int b, int dim);
<dd>Un cadre spécialement étudié pour
<a href="http://www.blablanux.org/">blablanux</a>, donc en permanente mutation.
<dt>int Image_cadre_pattern_0(Image_Desc *im, Image_Desc *pat, int l);
<dd>...
<dt>int Image_cadre_pattern_1(Image_Desc *im, Image_Desc *pat, int n);
<dd>...
<dt>int Image_cadre_pattern_2(Image_Desc *im, Image_Desc *pat, int n);
<dd>...
<dt>int Image_cadre2_pixx(Image_Desc *src, Image_Desc *dst, int p1, int p2);
<dd>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...
<dt>int Image_cadre_f(Image_Desc *im, int a, int b);
<dd>This func is a derivative of the _original_ cadre function
named 'Image_cadre_A' and located in file 'cadres.c'
<dt>int Image_cadre_burp_0(Image_Desc *img, int p1, int p2, int gval);
<dd>Deux dégradés sur toute la largeur/hauteur de l'image. Les params
<i>p1</i> et <i>p2</i> déterminent la largeur des bandes, en horizontal et
en vertical, <i>gval</i>
donnera l'intensité de la composante verte.
<dt>int Image_cadre_burp_2(Image_Desc *img, int sz, int pr, int pg, int pb);
<dd>Modifications chromatiques de largeur <tt>sz</tt>.
<dt>int Image_cadre_rasta_0(Image_Desc *img, int taille);
<dd>Première tentative de rastafarisation du cadre.
Le paramètre <tt>taille</tt> règle la largeur des bandes.
<dt>int Image_raz_sides(Image_Desc *im);
<dd>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
<a href="img-filtres.html">filtres</a>.
</dl>
<h2><a name="liens">liens</a></h2>
<p>
En fait, il serait convénient que je fasse une
<a href="http://la.buvette.org/images/cadres.html">page ouaibe</a>
avec quelques exemples de ces cadres.
D'autre part, dans le <i>kit</i> d'outils associé à la libimage, il y a
un programme qui <a href="img-outils.html#cadre">encadre</a> les images.
</p>
<p class="footer">
vous pouvez me rencontrer sur mon
<a href="http://foo.bar.quux.over-blog.com/">blog</a> où je poste
épisodiquement des nouvelles du kluge.<br>
Si votre demande est bien cadrée, je code le truc.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

95
Doc/img-calculs.html Normal file
View File

@ -0,0 +1,95 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: la doc des calculs !</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, Targa">
</head>
<body>
<a name="top"><h1>libimage / calculs</h1></a>
<p align=center>
<tt>dernière mise à jour: 14 octobre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="#luts">luts</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Cette page décrit les &quot;calculs&quot; que l'on peut faire
sur une image grace à la <a href="libimage.html">libimage</a>.
La frontière entre 'calculs' et
'<a href="img-operat.html">opérations</a>' est parfois assez floue...
</p>
<h2><a name="mesures">Mesures</a></h2>
<dl class="proto">
<dt>int Image_stats_zone_0(Image_Desc *img, Image_Rect *zone,
int *pmr, int *pmg, int *pmb,
int *pdr, int *pdg, int *pdb);
<dd>calcule sur une zone la moyenne et le delta <i>max-min</i> des composantes.
Une prochaine version devrait aussi calculer un truc dans le genre de
l'écart-type.
<dt>int Image_luminance(Image_Desc *s, Image_Desc *d, int f);
<dd>On multiplie la valeur des pixels par <tt>f/255</tt>. Théoriquement,
ce <tt>f</tt> 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.
<dt>int Image_minmax_RGB(Image_Desc *img, int *res);
<dd>Calcul des extremums sur les 3 composantes de l'image.
<dt>int Image_histo_RGB(Image_Desc *im, long *hr, long *hg, long *hb);
<dd>Calcul des histogrammes sur les 3 composantes R, G et B. Les trois tables
doivent être déclarées: <tt>long hX[256];</tt> et il devrait exister une
fonction pour les convertir en histogrammes cumulés.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="luts">LUTs</a></h2>
<p>
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.
</p>
<dl class="proto">
<dt>int Image_calclut_lin(int *lut, int v0, int v255);
<dd>Création d'une table linéaire de 256 valeurs:
lut[0]=v0 jusqu'à lut[255]=v255.
</dl>
<p>
D'autres calculs de <small>LUT</small>s sont en chantier, et sortiront
au grand jour probablement en 2010 (ou 2013 ? (ou 2014 ?)).
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
La rubrique des liens, toujours aussi vide. Mais bon, on le sait
que c'est vide...
Rattrapez vous <a href="libimage.html#liens">ici</a>
</p>
<p class="footer">
Si votre demande est NP complète, je patche quantiquement.<br>
<a href="http://tboudet.free.fr/cv.html">tTh calcule.</a></p>
</body>
</html>

123
Doc/img-combine.html Normal file
View File

@ -0,0 +1,123 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: combiner des images</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, Targa, combiner, mixage">
</head>
<body>
<a name="top"><h1 align=center>libimage / combiner des images</h1></a>
<p align=center>
<tt>dernière mise à jour: 27 septembre 2018</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="img-outils.html#combine">l'outil</a>]
[<a href="#liens">liens</a>]
</p>
<dl class="proto">
<dt>int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
int sy, int oy, int zak);
<small><i>ou</i> Image_combine_columns(...</small>
<dd> XXX
<dt>int Image_combine_checker(Image_Desc *s1, Image_Desc *s2,r
Image_Desc *d, int sx, int sy, int ox, int oy, int zak);
<dd> Ben, ça fait un damier...
<dt>int Image_combine_random_point(Image_Desc *s1, Image_Desc *s2,
Image_Desc *d, int yo);
<dd>On prend au (presque) hasard un point sur une des deux images. Le paramètre
<tt>yo</tt> peut varier entre 0 et 100.
<dt>int Image_combine_cercle_flou(Image_Desc *s1, Image_Desc *s2,
Image_Desc *d, int yo);
<dd> Il manque des paramètres à cette fonction pour le positionnement
du <i>cercle flou</i>, son diamètre et son intensité.
<dt>int Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2,
Image_Desc *d, int yo, int p1, int p2);
<dd>Tiens, aucun des 3 paramètres n'est utilisé ? Vraiment étrange.
<dt>
int
Image_combine_minmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int flg);
<dd>Si flag est à 1, on utilise le maximum, sinon, on utilise le minimum, et
cela pour chacune des composantes.
<dt>int Image_mix(Image_Desc *a, Image_Desc *b, Image_Desc *c, int k);
<dd>Mélange les composantes rgb de deux images. Le coefficient va de 0 à 10000,
mais vous pouvez tenter d'autres valeurs.
<dt>int Image_mix_rgb(Image_Desc *a, Image_Desc *b, Image_Desc *c,
int kr, kg, kb);
<dd> Pareil, sauf qu'il y a un coefficient par composante.
<dt>
int
Image_combine_4img_0( Image_Desc *s1, Image_Desc *s2,
Image_Desc *s3, Image_Desc *s4,
Image_Desc *dst);
<dd>
Je ne sais pas ce que ça va faire.
</dd>
<dt>
int Image_combine_Vdegrade(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int sens);<br>
int Image_combine_Hdegrade(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int sens);
<dd>Degradé horizontal ou vertical entre deux images.
Le paramètre 'sens' détermine quelle image sera à droite (en haut) du
résultat.
<dt>
int Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
</dt>
<dd>
En gros, si un pixel de <i>s2</i> n'est pas complètement noir,
il est recopié dans <i>d</i>. Sinon, on prend le pixel dans <i>s1</i>.
Une version de cette fonction avec les seuils paramétrables est
en chantier. Vous pouvez aussi aller consulter la
<a href="img-alpha.html">page</a> sur le canal alpha.
</dd>
<dt>
int Image_combine_power(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
</dt><dd>
Vous pouvez essayer d'échanger les deux images sources...
</dd>
<dt>
int Image_combine_XOR(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
</dt><dd>
Vous pouvez aussi essayer d'échanger les deux images sources, mais ça
ne marche pas très bien. Vous venez de comprendre.
</dd>
</dl>
<p>
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...
</p>
<p align=right><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p class="footer">
Le <a href="http://weblog.mixart-myrys.org/">blog</a> de l'auteur.
Si votre demande est accompagnée<br>d'une caisse de bon vin,
je patche à donf.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

113
Doc/img-couleurs.html Normal file
View File

@ -0,0 +1,113 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: utilisation des couleurs</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, RGBA, palette, CMJK">
</head>
<body>
<a name="top"><h1>libimage: les couleurs.</h1></a>
<p align=center>
<tt>dernière mise à jour: 12 janvier 2014</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="#palettes">palettes</a>]
</p>
<h2><a name="couleurs">Couleurs</a></h2>
<dl class="proto">
<dt>int Image_couleur_moyenne(Image_Desc *im, int *pr, int *pg, int *pb);
<dd>Calcul de la valeur moyenne de chacune des composantes RGB sur toute la
surface de l'image.
<dt>int Image_colors_2_Map(Image_Desc *s, Image_Desc *d, RGB_map *m, int mode);
<dd>&quot;remappe&quot; l'image source en utilisant uniquement les couleurs
contenues dans la palette. Le paramètre <tt>mode</tt> peut prendre les
valeurs 0, 1, 2, 11, 12 ou 13. Une démonstration de ces <i>remaps</i> est
<a href="http://tboudet.free.fr/libimage/">prévue</a>.
<i>Sauf que ça rame grave sa race !!!</i>
<dt>int Image_to_gray(Image_Desc *s, Image_Desc *d, int flag);
<dd>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 <a href="img-alpha.html">alpha</a>,
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.
<dt>int Image_to_gray_k(Image_Desc *s, Image_Desc *d, nt kr, int kg, int kb, int flag);
<dd>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.
<dt>Image_color_shift_rgb(Image_Desc *s, Image_Desc *d, int r, int g, int b);
<dd>Rotation des 3 composantes couleurs.
<dt>int Image_apply_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
<dd>Bon, voyons, comment expliquer ça?
<dt>int Image_gray_Map(Image_Desc *src, Image_Desc *dst, RGB_map *map);
<dd>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.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="palettes">Palettes</a></h2>
<dl class="proto">
<dt>int Image_load_color_Map(char *file, char *name, RGB_map *where);
<dd>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 <tt>where->nbre</tt>, la
valeur retournée par la fonction est le code d'erreur.<br>
Les palettes sont cherchées à divers
<a href="img-devel.html#path">endroits</a>.
<dt>int Image_save_color_Map(char *file, char *name, RGB_map *map);
<dd>Les colors maps sont censées etre compatible avec celles de FRACTINT,
mais il faudrait verifier. ymmv.
<dt>int Image_make_random_Map(char *nom, RGB_map *map, int nbre);
<dd>Remplissage de la palette <i>&amp;map</i> avec <i>nbre</i> couleurs
aléatoires.
<dt>int Image_make_222_Map(char *nom, RGB_map *map, int noise);
<dd>Fabrique une palette de 64 couleurs.
<dt>int Image_palette_3sinus(char *nom, RGB_map *ou, double pars[8]);
<dd>...
<dt>int Image_map2ppm(RGB_map *p, char *fname, char *comment);</dt>
<dd>Exportation d'une palette de couleurs dans un format utilisable
par <tt>ppmquant</tt>, qui permet de réduire le nombre de couleurs
d'une image.</dd>
</dl>
<p>Il existe un <a href="img-outils.html#plotmap">outil</a> pour dessiner
une de ces palettes de couleurs stockée dans un fichier.
Lequel appelle une fonction qui doit
être décrite <a href="img-plotters.html">ici</a>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
Si votre demande est colorée, je patche à donf.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

62
Doc/img-dessin.html Normal file
View File

@ -0,0 +1,62 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: comment dessiner ?</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et StChinian rosé">
<meta name="keywords" content="libimage, krabulator, operations">
</head>
<body>
<a name="top"><h1>libimage / les dessinateurs</h1></a>
<p align=center>
<tt>dernière mise à jour: 23 janvier 2014</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-fichiers.html#ptl">points list</a>]
</p>
<dl class="proto">
<dt>int
Image_paint_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b);
<dd>peindre un rectangle est facile.
<dt>int
Image_draw_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b);
<dd>dessiner les bords d'un rectangle, c'est <i>kwol</i> aussi.
<dt>int
Image_draw_line(Image_Desc *i, int x1, int y1, int x2, int y2, RGBA *q);
<dd>Et les plus courageux d'entre vous peuvent aussi essayer de tirer
un trait sur leur passé...
</dl>
<p>Il serait <a name="image_rect">bon</a> de rappeler ce qu'est une
structure <tt>Image_Rect</tt>. C'est simple, à la limite du rudimentaire,
et probablement pas très stable, <a href="img-devel.html">évolutions</a>
en chemin.
</p>
<pre class="code">
typedef struct {
int x, y;
int w, h;
long reserved;
} Image_Rect;
</pre>
<p class="HDP"><a href="#top">haut de page</a></p>
<p align=center>[ <a href="http://tboudet.free.fr/cv.html">tTh dessine</a> ]</p>
</body>
</html>

67
Doc/img-detect.html Normal file
View File

@ -0,0 +1,67 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les detecteurs</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, krabulator, operations">
</head>
<body>
<a name="top"><h1>libimage / les détecteurs</h1></a>
<p align=center>
<tt>dernière mise à jour: 21 janvier 2010</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-fichiers.html#ptl">points list</a>]
</p>
<dl class="proto">
<dt>int Image_seuil_RGB(Image_Desc *s, Image_Desc *d, int r, int g, int b);
<dd>Seuillage des trois composantes d'une image. Les pixels dans l'image de
destination auront les valeurs 0 ou 255.
<dt>int Image_AutoSeuilRGB(Image_Desc *s, Image_Desc *d);
<dd>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.
<dt>int Image_AutoSeuilGray(Image_Desc *s, Image_Desc *d, int *ps);
<dd>Seuillage sur les niveaux de gris (calculés par la formule <tt>r+g+b</tt>,
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 <tt>*ps</tt> est le seuil calculé, compris entre 0 et 3x256,
soit <b>784</b>. <a href="img-effets.html">Ymmv</a>.
<dt>
int Image_detect_flat_gray(Image_Desc *src, Image_Desc *dst, int param, int r1);
<dd>Détection des zones où, sur un voisinage 3x3, l'ecart entre le maxi et le
mini du gris est inférieur à 'param'.
<dt>int Image_pix2ptl(Image_Desc *img, int seuil);</dt>
<dd>Voilà donc une fonction faite pour torturer <b>vraiment</b> la capacité
de votre machine à swapper... Et comme c'est un truc écrit àlc, le fichier
résultat est nommé <tt>pixels.ptl</tt> et peut être <b>très</b> gros.</dd>
</dl>
<p align=right><a href="#top">haut de page</a></p>
<hr><!-- ----------------------------------------- -->
<p align=right>
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est détectante, je patche comme un gruiik.<br>
<a href="#top">haut de page</a></p>
<p align=center>[ <a href="http://tboudet.free.fr/cv.html">tTh détecte</a> ]</p>
</body>
</html>

280
Doc/img-devel.html Normal file
View File

@ -0,0 +1,280 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les regles du programmeur</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Cuisse de Pintade à l'ail, Riz, Morgon">
<meta name="keywords" content="libimage, coding style, Boudet, tontonth">
</head>
<body>
<h1><a name="top">en vrac pour les codeurs...</a></h1>
<p align="center"><tt>dernière mise à jour: 3 janvier 2014</tt></p>
<p class="menuhaut">
[<a href="README.txt">README</a>]
[<a href="image77.html">fortran</a>]
[<a href="img-essais.html">essais</a>]
[<a href="#porting">porting</a>]
<br>
[<a href="#bugs">bugs</a> et <a href="BUGS.txt">BUGS</a>]
[<a href="#projets">projets</a>]
[<a href="#compilation">compilation</a>]
[<a href="#types">types</a>]
[<a href="#return">return codes</a>]
<br>
[<a href="#lacunes">les manques</a>]
[<a href="#optimize">Optimisations</a>]
[<a href="#outils">outils divers</a>]
</p>
<h2><a name="utsl">Use the sources, Luke</a></h2>
<p>
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
<i>vrac</i>...
</p>
<p>
On peut <a href="img-marquage.html">marquer</a> une image.
Il existe quelques <a href="#macros">macros</a> pour abstraire
certaines choses, mais ce n'est pas très fini.
</p>
<h2><a name="bugs">les bugs</a></h2>
<p>
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:
</p>
<pre class="code">
foo = Image_alloc(bla...);
Image_tripote(foo, bar);
Image_DeAllocate(foo);
free(foo); <b>/* ne pas oublier ça... */</b>
</pre>
<p>
A ce moment, les zones mémoires contenant les pixels de l'image sont rendues
au gestionnaire de mémoire, <b>mais</b> l'en-tête du descripteur d'image est
encore <i>malloc-é</i>. Il convient donc de rajouter un <tt>free(foo)</tt>.
</p>
<p>
<b>Xv n'affiche pas les TGA fabriqués par Libimage ?</b>
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 <i>workaround</i> est simple:
il faut ajouter <tt>Image_set_comment(img, &quot;&quot;);</tt> avant
d'enregistrer le fichier afin d'enlever le commentaire.
Je pense même qu'il y a un truc dans le Makefile.
</p>
<p><b>le flag 'modified' du descripteur d'image est mal géré.</b>
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.</p>
<p>
Par contre, le fait que certaines fonctions ne semblent pas finies n'est
<i>pas</i> un bug. C'est un 'undocumented feature'. Et qu'il manque la
documentation, c'est le <i>lazzy effect</i>.
</p>
<h2><a name="projets">les projets</a></h2>
<p>
Début 2007, j'ai découvert que le compilateur <tt>g77</tt> était un
produit en fin de vie, et que les Linux récents avaient de plus en plus
tendance à préférer <tt>gfortran</tt>. Il est donc probable que
<a href="image77.html">l'interface</a> actuelle soit mise à l'écart
et remplacée par un équivalent plus moderne.
</p>
<h2><a name="porting">le portage</a></h2>
<p>
Merci au généreur donateur d'une <i>Sun U5</i> grace auquel j'ai enfin pu
finaliser l'adaptation
du machin à une autre architecture que le trop commun <i>i386</i> sous Linux,
en l'occurence un processeur <i>UltraSparc</i>, tournant sous <i>OpenBSD 4.4</i>.
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.
</p>
<p>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 <a href="http://dinorama.fr/">dino</a>),
et que le Gcc est également *vieux* :
<tt>gcc version 4.0.3 (Debian 4.0.3-1)</tt>. 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é:
</p>
<dl>
<dt><tt>alloca.h</tt>
<dd>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
<tt>CC_HACKS=-DNEED_ALLOCA_H</tt>.
</dd>
<dt>L'emplacement des <tt>.h</tt></dt>
<dd>Par flemme de chercher une autre solution, je les place systématiquement
dans <tt>/usr/local/include</tt>, et le Gcc de l'Open44 ne va pas les
chercher à cet endroit là.
Tip: <b><tt>export C_INCLUDE_PATH=/usr/local/include</tt></b>
dans le <tt>~/.profile</tt>.
</dd>
<dt>L'emplacement des <tt>.a</tt> et <tt>.so</tt>
<dd>Même Gcc, même punition. Après quelques essais rapidement désastreux avec
le <tt>ld.so.conf</tt>, une lecture plus attentive des manpages m'a conduit
à une (presque) même solution:
<b><tt>export LIBRARY_PATH=/usr/local/lib</tt></b> dans le même
<tt>~/.profile</tt>.
</dd>
</dl>
<p>
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 <a href="img-outils.html#porting">bon</a> chemin.
</p>
<h2><a name="optimize">Optimisations</a></h2>
<p>À priori, il reste pas mal de choses à faire, surtout pour rendre les
boucles X-Y plus <i>cache-friendly</i>. Les buffers contenants les images
étant organisés en tableaux de lignes, il y a probablement quelques
<i>hit/mess</i> à grapiller. D'un autre coté, pour le moment, juste
ça marche...
</p>
<h2><a name="path">chemins de recherche</a></h2>
<p>
Bah, fatigué de devoir recopier mes fichiers .MAP de
<a href="img-couleurs.html#palettes">palette</a> à droite et à gauche,
j'ai ajouté une func qui cherche dans quelques endroits. Donc, j'essaye
en série:
</p>
<ol>
<li> le répertoire courant.
<li> le rep dans la variable <tt>$LIBIMAGE_PATH</tt>
<li> le chemin <i>hardcoded</i>: $(DESTDIR)/share/libimage
</ol>
<h2><a name="compilation">compilation</a></h2>
<p>
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.
</p>
<p>
En attendant, les variables à positionner pour l'install sont:
</p>
<ul>
<li><tt>DESTDIR</tt>: /usr/local
<li><tt>HTML_DIR</tt>: /usr/local + le répertoire html recevra les pages
que vous êtes en train de lire.
<li><tt>SHARED_FILES</tt>: $(DESTDIR)/share/libimage contiendra les fichiers
de fontes et les colors maps.
</ul>
<p>
A la compilation, on peut aussi utiliser quelques <tt>-DMACHIN=42</tt>
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:
<i>plotter</i> en dehors de l'image. Donc, avec un <tt>-DABORT=1</tt>,
les conditions anormales génererons un <small>COREDUMP</small> analysable
avec gdb, si vous n'avez pas oublié de régler votre <tt>ulimit -c</tt>
à une valeur raisonnable.
</p>
<p><b>alloca.h</b> 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 <tt>alloca</tt>. (2007-12-30) investigations
en cours. Sans compter que le problème va se poser aussi avec NetBSD.
</p>
<h2><a name="types">type de données</a></h2>
<p>
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.
</p>
<ul>
<li><b>pr100</b> Seuil de probabilité pour un choix randomatique. Une valeur
comprise entre 0 et 99. Exemple: le
<a href="img-povhf15.html#bruit">bruitage</a> des HFs.
</ul>
<p>Les hackeurs trouveront dans le fichier <tt>imprime.c</tt> une fonction :
<i>Image_print_sizeof_structs</i>, qui affiche les tailles des diverses
structures utilisées par les rouages internes.
</p>
<h2><a name="return">return codes</a></h2>
<p>
Il faut regarder les <i>#define</i> dans <tt>tthimage.h</tt> et la fonction
<a href="libimage.html#messages">Image_err2str</a> dans <tt>msglib.c</tt>.
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é.
</p>
<h2><a name="macros">macros</a></h2>
<p>
Elles sont habilement dissimulées dans le fichier <tt>tthimage.h</tt>, mais
je ne leur porte qu'une confiance limitée.
</p>
<h2><a name="outils">Les outils</a></h2>
<p>
Deux dumpeurs de pixels dans <tt>dumppix.c</tt>. 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
<a href="img-outils.html">package</a> qui contient quelques <i>tools</i>
assez performants.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="lacunes">Ce qui manque...</a></h2>
<p>
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.
</p>
<!-- ------------------------------------------------ -->
<p class="footer">
Bon courage à tous, et n'oubliez pas de regarder
<a href="http://la.buvette.org/cv.html">qui</a> a pondu ce kluge,
et en est presque fier...
</p>
</body>
</html>

130
Doc/img-df3.html Normal file
View File

@ -0,0 +1,130 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les df3 de povray</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, krabulator, operations">
</head>
<body>
<a name="top"><h1>libimage / les df3 de povray</h1></a>
<p align=center>
<tt>dernière mise à jour: 10 novembre 2013</tt><br>
<i>
<a href="http://tboudet.free.fr/libimage/img-df3.html">#</a> et
<a href="http://la.buvette.org/devel/libimage/img-df3.html">#</a>
</i>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-povhf15.html">height fields</a>]
</p>
<p class="explique">
The density_file pattern is a 3-D bitmap pattern that occupies a unit
cube from location &lt;0,0,0&gt; to &lt;1,1,1&gt; 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.
</p>
<p>
Bon, il faut avouer que le code actuel est totalement buggué, que son
<small>API</small> est pitoyable, et que je n'y consacre pas autant
d'énergie qu'il le faudrait. Vous pouvez quand même aller
<a href="/POV/df3.html">voir</a> l'avancement des essais.
</p>
<h2>Primitives</h2>
<p>
C'est toujours en cours de mise au point. Les <small>API</small> ne sont
pas encore figées.
</p>
<dl class="proto">
<dt>DensityF3Head * Image_df3_alloc(char *nom, int x, int y, int z, int b);
<dd>Création d'un objet de type <small>DF3</small>. Les trois paramètres
<tt>x, y &amp; z</tt> sont les dimensions, <tt>b</tt> 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 <i>double</i>, avec 1.0 représentant
la valeur maximum.
<dt>int Image_df3_free(DensityF3Head *ptr);
<dd>Destruction féroce d'un objet de type <small>DF3</small>. Si la valeur
de retour n'est pas nulle, c'est catastrophe.
<dt>int Image_df3_put(DensityF3Head *ptr, int x, int y, int z, double dv);</dt>
<dd>Dépose une valeur dans le machin. Retourne <small>INVALID_PARAM</small>
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.</dd>
<dt>int Image_df3_get(DensityF3Head *ptr, int x, int y, int z, double *pdv);</dt>
<dd>Lecture d'une valeur dans le machin. Si en dehors du cube,
renvoie <small>INVALID_PARAM</small>.</dd>
<dt>int Image_print_DF3head(DensityF3Head *h, char *txt, int flag);
<dd>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é.
<dt>int Image_df3f_get_dims(char *fname, int dims[], int display);
<dd>Lecture des dimensions d'un fichier df3. L'argument <tt>dims</tt>
doit être un <tt>int dims[3]</tt>. Si <tt>display</tt> est différent de
zéro, des trucs seront affichés.
<dt>int Image_df3_export(DensityF3Head *ptr, char *fname, int nbbytes);</dt>
<dd>Enregistrement des données dans un fichier. Si <tt>nbbytes</tt> 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.
</dl>
<h2>Essais divers</h2>
<p>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 <i>bricolages divers</i> pour
se rassurer si elles ne fonctionnnent pas.
</p>
<dl class="proto">
<dt>int Image_df3_xper_0(Image_Desc *src, char * fname_df3, int k);
<dd>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.
<dt>int Image_df3_plot_histo(char *fname_df3, char *nomtga, int flag);
<dd>Histogramme linéaire du contenu d'un fichier DF3. Utilité plus que
douteuse. Nous allons essayer da faire mieux.
<dt>int Image_df3f_2_txt(char *nomdf3, char *nomtxt);
<dd>Dump d'un fichier df3 dans un fichier texte, à priori <i>parsable</i>
par les outils Unix classiques.
<dt>int
Image_df3f_2_povinc(char *nomdf3, char *nominc, char *nomobj, int k, double dv);</dt>
<dd>C'est cette fonction qui est actuellement en cours de test dans cette
<a href="http://la.buvette.org/POV/ex/df3.html">page</a>, et les résultats
semblent prometteurs. Le paramètre <tt>k</tt> 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.
</dd>
</dl>
<p>Il existe d'autres fonctions pour traiter les types de données
qu'utilise POVray : les <a href="img-povhf15.html">champs d'altitude</a> pour
le moment.</p>
<hr noshade>
<p align=center>[ <a href="http://tboudet.free.fr/cv.html">tTh cherche</a> ]</p>
</body>
</html>

82
Doc/img-dither.html Normal file
View File

@ -0,0 +1,82 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les 'ditherings'</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, buv3tt3, Boudet, dither">
</head>
<body>
<h1><a name="top">libimage / les 'ditherings'</a></h1>
<p align=center>
<tt>dernière mise à jour: 23 octobre 2013</tt><br>
</p>
<p>
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: <b>0</b> et <b>uh</b>. Pour commencer, je conseille
vivement de donner la valeur <b>255</b> à <b>uh</b>.
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">libimage</a>]
[<a href="#sauvegarde">sauvegarde</a>]
</p>
<dl class="proto">
<dt>int Image_dither_Bayer_0(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être, en général, mis à 255.
<dt>int Image_dither_crude(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être, en général, mis à 255.<br>
Je ne suis pas très content de celui-ci, donc il risque de changer dans
le futur...
<dt>int Image_dither_2x2(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être, en général, mis à 255.
<dt>int Image_dither_3x3_0(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être, en général, mis à 255.
<dt>int Image_dither_3x3_1(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être, en général, mis à 255, mais d'autres valeurs
marchent bien aussi.
<dt>int Image_dither_3x3_2(Image_Desc *s, Image_Desc *d, int uh);
<dd><i>cette fonction n'est pas encore codée, ni même imaginée.</i>
<dt>int Image_dither_seuil_random(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> 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.
<dt>int Image_dither_simple_error(Image_Desc *s, Image_Desc *d, int uh);
<dd><b>uh</b> doit être <b>absolument</b> mis à 255. Parce que la fonction
contient un <i>bug sournois</i> que je tente de trouver...
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="sauvegarde">sauvegarde</a></h2>
<p>
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
<a href="img-fichiers.html#pcx">Pcx</a> en 16 couleurs qui semble adapté,
mais ce n'est qu'un projet <i>:(</i>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
<a href="http://tboudet.free.fr/cv.html">seeking for a job</a>
</p>
</body>
</html>

202
Doc/img-effets.html Normal file
View File

@ -0,0 +1,202 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: la doc des effets !</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, tontonth, effects, Targa">
</head>
<body>
<a name="top"><h1>libimage / effets</h1></a>
<p align=center>
<tt>dernière mise à jour: 14 décembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="#effets">effets</a>]
[effets <a href="#effets2">2</a> &amp; <a href="#effets3">3</a>]<br>
[<a href="#rgbmask">rgbmask</a>]
[<a href="#colorize">colorize</a>]
[<a href="#essais">essais</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Cette page décrit les &quot;effets spéciaux&quot; que l'on peut appliquer
sur une image graçe à la <a href="libimage.html">libimage</a>.
Et je suis bien d'accord, il manque des exemples. Vous pouvez en
générer rapidement quelque-uns, en faisant appel à une
<a href="img-essais.html">fonction de test</a>. Ou plus simplement
en utilisant
<a href="http://la.buvette.org/devel/libimage/img-outils.html#effects">l'outil</a>
approprié.
</p>
<h2><a name="effets">effets</a></h2>
<dl class="proto">
<dt>int Image_water(Image_Desc *source, Image_Desc *but, int intensite)</b>
<dd>déplace randomatiquement les pixels comme si de l'eau était tombé
sur une aquarelle. Attention, il semble y avoir un <i>bug</i> dans
cette fonction.
<dt>int Image_noise(Image_Desc *source, Image_Desc *but, int intensite)</b>
<dd>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.
<dt>int Image_mirror(Image_Desc *src, Image_Desc *dst, int res)</b>
<dd>retourne une image rgb[a] de droite à gauche, comme dans un miroir.
<dt>int Image_upside_down(Image_Desc *src, Image_Desc *dst, int res)</b>
<dd>Renverse une image de haut en bas ou de droite à gauche. Il ne faut pas
mettre la même image en source et destination.
<dt>int Image_swap_lines(Image_Desc *src, Image_Desc * dst)<br>
int Image_swap_cols(Image_Desc *src, Image_Desc * dst)</b>
<dd>Echange des lignes (colonnes) paires et impaires de l'image.
RGB uniquement hélas...
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="effets2">effets 2</a></h2>
<dl class="proto">
<dt>int Image_sinwave_1(Image_Desc *source, Image_Desc * but, double table[6])</b>
<dd>Déformation étrange d'une image. Je ne sais absolument pas ce que doit
contenir la table.
<dt>int Image_sinwave_2(Image_Desc *source, Image_Desc * but, double table[6])</b>
<dd>Déformation étrange d'une image. Je ne sais absolument pas ce que doit
contenir la table.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="effets3">effets 3</a></h2>
<p>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 <a href="http://tontonth.free.fr/videos/">povesques</a>.
Ensuite, quand ils seront fixés, peut-être je changerais leur nom,
tout en gardant un alias dans le source <tt>effects3.c</tt>.
</p>
<dl class="proto">
<dt>int
Image_effect_x_0(Image_Desc *src, Image_Desc *dst, int kr, int kg, int kb)</b></dt>
<dd>Déja plus de 4 ans de mise au point, et c'est pas encore fini...</dd>
<dt>int
Image_effect_x_1(Image_Desc *src, Image_Desc *dst)</b></dt>
<dd>Déja plus de 4 ans de mise au point, et c'est pas encore fini...</dd>
<dt>int
Image_effect_x_3(Image_Desc *src, Image_Desc *dst, int kx, int ky, char *comp)</b></dt>
<dd>Déja plus de 4 ans de mise au point, et c'est pas encore fini...</dd>
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="rgbmask"><h2>rgbmask</h2></a>
<p>
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
<a href="img-fichiers.html#jpeg">JPEG</a>.
</p>
<dl class="proto">
<dt>int Image_rgbmask_H(Image_Desc *src, Image_Desc *dst, int gris);
<dd>Dans le sens horizontal...
<dt>int Image_rgbmask_V(Image_Desc *src, Image_Desc *dst, int gris);
<dd>Dans le sens vertival...
<dt>int Image_rgbmask_2(Image_Desc *src, Image_Desc *dst, int gris);
<dd>Bon, c'est pas mal, mais c'est quand même très dépendant des
dimensions de l'image.
<dt>int Image_rgbmask_R(Image_Desc *src, Image_Desc *dst, int gris);
<dd>Ah, celle-là semble prometteuse. En jouant sur la pondération
de l'aléa, on doit pouvoir obtenir quelques trucs sympas...
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="colorize"><h2>colorize</h2></a>
<p>
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.
</p>
<dl class="proto">
<dt>int Image_BiColor_0(Image_Desc *src, Image_Desc *dst, int k)
<dd>Si c'est clair, ça devient sombre. Si c'est sombre, ça devient clair.
Vice-versa et réciproquement inclus. Le paramètre <tt>k</tt> ne sert à
rien et doit être mis à 0.
</dl>
<p>
Oh, bien entendu, ces tripotages de pixels ça n'est pas au niveau de la
<a href="http://foo.buvette.org/bf/pm/">troiD</a> de
<a href="http://foo.buvette.org/bf/hf/">merde</a> faite
sous <a href="http://slackware.com/">Linux</a>, mais j'ai quand même
dans l'idée d'appliquer ces trucs à des séquences vidéo ou
des <a href="http://la.buvette.org/photos/myrys/g/">GIfs animées</a>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="essais"><h2>Quelques essais</h2></a>
<p>
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.
</p>
<dl class="proto">
<dt>int Image_call_recursion(Image_Desc *image, Image_Desc *dest, int param);
<dd>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.
</dl>
<p>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.
</p>
<dl class="proto">
<dt>int Image_mosaic_simple(Image_Desc *src, Image_Desc *dst);
<dd>Comme le nom l'indique clairement, c'est un truc simple.
<dt>int Image_mosaic_0(Image_Desc *src, Image_Desc *dst, int sx, int sy, int flg);
<dd>Comme le montre clairement le prototype, il y a des paramètres.
<tt>sx</tt> et <tt>sy</tt> sont les dimensions des pavés (il parait qu'il faut
dire &quot;tuiles&quot; maintenant) que l'on va examiner et traiter. Quand à
<tt>flg</tt>, je pense qu'il ne sert à rien, et qu'il faut mettre 0.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
La classique rubrique des liens, toujours aussi vide.
Rattrapez vous <a href="libimage.html#liens">ici</a> ou
<a href="img-television.html">là</a>.
</p>
<p class="footer">
vous pouvez me contacter sur mon
<a href="http://foo.bar.quux.over-blog.com/">blog</a><br>
Si votre demande est effective, je patche avec de la poudre verte.<br>
</p>
</body>
</html>

82
Doc/img-essais.html Normal file
View File

@ -0,0 +1,82 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les essais</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, tontonth, essais">
</head>
<body>
<h1><a name="top">libimage / les essais</a></h1>
<p align=center>
<tt>dernière mise à jour: 20 janvier 2010</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-devel.html">devel</a>]
</p>
<p>
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 <b><tt>essais.c</tt></b> que vous trouverez dans
l'<a href="libimage.tar.gz">archive</a>.
En théorie, il y a des explications dans <b><tt>essais.h</tt></b> à
consulter de préférence à cette page ouaibe, car les prototypes de
ces fonctions d'essayage changent de temps à autre. En un mot comme
en 4 lettres: <small>UTSL</small>.
</p>
<dl class="proto">
<dt>int Test_rgbmask(char *srcname);
<dd>En chantier actuellement.
<dt>void Test_des_patterns(char *prefix, int foo, int bar);
<dd>La <a href="img-patterns.html">page</a> 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 <tt>prefix</tt> vous permet de préciser le chemin vers les
images générées, par exemple &quot;/tmp/pattern&quot; vous donnera
des noms de fichiers du genre <tt>/tmp/pattern_042.tga</tt>.
<dt>void Test_Egalisations(char *nomsource);
<dd>Essai des <a href="img-operat.html#egal">égalisations</a>.
Image résultante: <a href="aaaa_egal.png">aaaa_egal.tga</a> dans le
répertoire de travail. A gauche l'image originale, au milieu, l'algo
<tt>RGB</tt>, et à droite l'algo <tt>mono_0</tt>.
<dt>void Test_Dithering(char *nomsource);
<dd>Essais des <a href="img-dither.html">tramages</a>.
On passe en revue: <tt>dither_Bayer_0</tt>, <tt>dither_seuil_random</tt>
<tt>dither_simple_error</tt> et <tt>dither_double_seuil</tt>.
L'image d'origine est tout d'abord réduite de moitié, puis les
nombreux résultats sont collés dans une
<a href="aaaa_dithering.png">image unique</a>.
<dt>void Test_Effects_A(char *nomsource, int flag);
<dd>Démonstration de quelques <a href="img-effets.html">effets</a>.
L'image source est réduite de moitié. Le flag doit être (pour le
moment) mis à zéro.
</dl>
<p>
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 <tt>aaaa</tt>.
Vous avez été prévenus. D'autre part, dans
<a href="img-outils.tar.gz">l'archive</a> des
<a href="img-outils.html">outils</a>, il y a plein de
scripts shell pour essayer plein de trucs.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
</body>
</html>

262
Doc/img-fichiers.html Normal file
View File

@ -0,0 +1,262 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: le(s) format(s) de fichier</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, convpht, TGA, Fits, Boudet, Targa, PHT, bmp">
</head>
<body>
<h1><a name="top">libimage / fichiers</a></h1>
<p align=center>
<tt>dernière mise à jour: 19 mars 2010</tt><br>
</p>
<p>
Cette page décrit les différents formats de fichier que sait gérer
la <a href="libimage.html">libimage</a>.
Le format de fichier <i>originel</i> de cette bibliothèque est le
<b>.TGA</b> 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 <small>BOUTISME</small> est le
plus flagrant: en gros vous risquez le coredump sur autre chose qu'un i386.
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
<br>
[<a href="#tga">TGA</a>]
[<a href="#bmp">BMP</a>]
[<a href="#pcx">PCX</a>]
[<a href="#pht">PHT</a>]
[<a href="#pnm">PNM</a>]
[<a href="#fits">FITS</a>]
[<a href="#jpeg">JPEG</a>]
[<a href="#ptl">PTL</a>]
[<a href="#eps">EPS</a>]
<br>
[<a href="img-outils.html#export">export</a>]
[<a href="#liens">liens</a>]
</p>
<h2><a name="tga">TGA</a></h2>
<dl class="proto">
<dt>int Image_TGA_save(char *filename, Image_Desc *img, int compress);
<dd>Le paramètre <tt>compress</tt> doit actuellement être à 0. Fonction
qui ne semble plus victime de boutisme. Par contre, il manque <i>toujours</i>
la compression.
<dt>int
Image_TGA_save_component(char *nom, Image_Desc *img, char channel, int comp);
<dd>La composante <tt>channel</tt> ('r', 'g' ou 'b') sera sauvée sous la
forme d'un tga monochrome avec une palette.
Et il manque aussi la compression.
<dt>Image_Desc * Image_TGA_alloc_load(char *nom);
<dd>...... 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, <a href="img-devel.html#utsl">utsl</a>.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="bmp">BMP</a></h2>
<dl class="proto">
<dt>Image_BMP_save_24(char *filename, Image_Desc *img, int flag);
<dd>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.
<dt>int Image_BMP_infos(char *nom, int *pw, int *ph, int *pt, int verb);
<dd>Récupère, et éventuellement affiche (si verb!=0) quelques informations
pertinentes sur un fichier bmp. Le retour <tt>*pt</tt> contient le nombre
de bits par pixel.
<dt>Image_Desc * Image_BMP_alloc_load(char *nom, int reserved);
<dd>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.
</dl>
<p>Bien évidement, la mauvaise qualité de la gestion de ce format est
la conséquence de la flemme de <i>tTh</i>. Si vous voulez voir ça de
plus près, il y a un <tt>testbmp.c</tt> dans le tarball.</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="pcx">PCX</a></h2>
<p>
<font color="ff0000">En cours...</font><br>
Première étape: les fichier en 16
couleurs à palette. Mais ça ne marche pas encore...
Dommage, ça serait bien pour les <a href="img-dither.html">dithering</a>.
<br>
Deuxième étape: les images binaires, qui seront bien utiles pour
les <a href="img-bitplane.html">bitplanes</a>.
</p>
<dl class="proto">
<dt>int Image_PCX_fileinfo(char *nom);
<dd>Affiche toutes les informations que l'on envisage de
trouver dans le header d'un fichier PCX.
<dt>int Image_wrPCX_8colors(char *nom, Image_Desc *im);
<dd>Euh, comment dire ?... Ça ne marche probablement pas.
</dl>
<p>Bien évidement, la mauvaise qualité de la gestion de ce format est
la conséquence de la flemme de <i>tTh</i>. Si vous voulez voir ça de
plus près, il y a un <tt>testpcx.c</tt> dans le tarball.</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="pht">PHT</a></h2>
<p>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é.
</p>
<pre>
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
</pre>
<p>
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 :)<br>
</p>
<dl class="proto">
<dt>int Image_PHT_save_component(char *name, Image_Desc *i, char col);
<dd>'name' est le nom du fichier, l'extension <b>.pht</b> est recommandée.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="pnm">PNM</a></h2>
<p>
<b>PNM</b> est l'acronyme de <i>Portable Net Map</i>. 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 <a href="http://netpbm.sourceforge.net/doc/">Ternet</a>.
</p>
<dl class="proto">
<dt>int Image_wr_pbm_0(char *nom, Image_Desc *im, char channel);
<dd>Sauvegarde d'une image monochrome, le seuil étant à 128.
Le paramètre 'channel' est R,G,B ou A.
<dt>int Image_wr_ppm_0(char *nom, Image_Desc *im, int mode);
<dd> 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 <b>très</b> gros.
<dt>int Image_wr_pgm_0(char *nom, Image_Desc *im, char channel);
<dd>Ecriture d'un fichier en niveau de gris du canal spécifié.
</dl>
<p>
Vous pouvez aussi regarder <a href="img-povhf15.html#fonctions">les HF</a>
pour une autre utilisation de ce format PNM.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="fits">FITS</a></h2>
<p>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
<a href="http://www.eso.org/eclipse/">Eclipse</a> et revenez me faire part
de vos découvertes.</p>
<p align=right><a href="#top">haut de page</a></p>
<h2><a name="jpeg">JPEG</a></h2>
<p>
A la demande générale, j'ai rajouté un <i>hack bien crade</i> pour sauvegarder
une
image en jpeg. Mais il faut avoir l'utilitaire <b>cjpeg</b> sur votre système.
</p>
<dl class="proto">
<dt>int Image_system_cjpeg(Image_Desc *img, char *fname, int quality);
<dd><i>img</i> est une image RGB en mémoire qui va être convertie en Jpeg sous
le nom <i>fname</i> avec un facteur de qualité compris entre 0 et 100.
Il suffira de taper <font color="green">man cjpeg</font> au prompt de votre
shell favori pour en apprendre plus.
</dl>
<p>
Attention, c'est vraiment un kludge, et ça risque de ne pas marcher à tous
les coups...
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="ptl">Points List</a></h2>
<p>
C'est nouveau, ça vient de sortir (enfin, il y a 8 ans que ce n'est
<a href="img-ptlist.html">pas fini</a>).
Et pour le moment, comme ça ne marche pas trop bien, ça ne sert à rien.
En bref, ce sont des listes de points <i>(x,y,h,v)</i> qui seront
destinées à nourrir un programme <a href="image77.html">fortran</a> qui
fabriquera des <a href="img-povhf15.html">height fields</a>.
</p>
<p>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.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="eps">Encapsulated Postscript</a></h2>
<p>
Le but premier est de construire des images utilisables par <tt>LaTeX</tt>,
par exemple pour la version imprimée des
<b>Sources de Tar</b>.
La seconde étape sera de les utiliser dans des logiciels de PAO plus,
ahem, institutionnels...
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<p>
L'habituelle rubrique des liens:<br>
L'excellent <a href="http://www.wotsit.org/">wotsit</a> décrit pleins
de formats de toutes sortes de fichiers. Il existe aussi un
utilitaire d'<a href="img-outils.html#export">exportation</a>
reprenant certains des formats décrits ici.
D'autre part, <a href="http://www.imagemagick.org/">Image Magick</a>
est une bonne solution à tous ces problèmes de formats de fichier
pour les images.
</p>
<p class="footer">
vous pouvez me troller avec
<a href="http://foo.bar.quux.over-blog.com/">vigueur</a><br>
Si votre demande est simple, je patche à donf.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

93
Doc/img-filtres.html Normal file
View File

@ -0,0 +1,93 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les filtrages</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, krabulator, Boudet, filtres,
gradient, sobel">
</head>
<body>
<a name="top"><h1>libimage / les filtrages</h1></a>
<p align=center>
<tt>dernière mise à jour: 28 novembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#filtres">filtres</a>]
[<a href="#liens">liens</a>]
</p>
<p>
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.
</p>
<a name="filtres"><h2>filtres</h2></a>
<dl class="proto">
<dt>int Image_convolueur3(Image_Desc *in, Image_Desc *out, int *mat);
<dd> <i>Je ne sais pas si le nom 'convolueur' est bien adapté...</i>
<dt>int Image_lissage_3x3(Image_Desc *in, Image_Desc *out);
<dd> Moyennage des pixels sur la matrice 3x3.
<dt>void Image_filtre_display(FILE *ou, int *mat);
<dd>Affichage des valeurs d'un filtre. <tt>ou</tt> précise à quel endroit
l'envoyer. Vous pouvez utiliser <tt>stdout</tt>, <tt>stderr</tt>
ou un fichier que vous avez préalablement ouvert.
<dt>int
Image_filtre_random(Image_Desc *src, Image_Desc *dst, int p1, int p2);
<dd>Les 9 coefficients du filtre sont choisis au hasard entre p1 et p2.
N'oubliez pas d'appeller <i>srand(getpid())</i> si vous obtenez la même
chose à chaque course :-)
<dt>int Image_filtre_passe_bas(Image_Desc *in, Image_Desc *out);
<dd>parfois, il m'arrive de me demander si ce filtre n'est pas équivalent
au lissage 3x3...
<dt>int Image_filtre_passe_haut(Image_Desc *in, Image_Desc *out);
<dd>euh...
<dt>int Image_filtre_Prewitt(Image_Desc *src, Image_Desc *dst, int rotation);
<dd>C'est un filtre directionnel, et le paramètre <tt>rotation</tt> permet
de le faire tourner.
<dt>int Image_filtre_Sobel(Image_Desc *src, Image_Desc *dst, int rotation);
<dd>C'est un filtre directionnel, et le paramètre <tt>rotation</tt> permet
de le faire tourner.
</dl>
<p>
Certaines primitives du module 'filtres.c' necessitent une lecture
approfondie du code source. ymmv.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
Comme d'habitude, utilisez votre <a href="http://www.exalead.fr/">g00gl3</a>
favori, et tentez des mots-clefs du genre 'convolution' ou 'sobel filter'.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez essayer de me contacter:<br>
mon adresse est <a href="http://la.buvette.org/ego/cv.html">là</a><br>
Si votre demande est scientifique, je patche comme un goret.<br>
</p>
</body>
</html>

98
Doc/img-marquage.html Normal file
View File

@ -0,0 +1,98 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: marquer une image</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, marquage, Thierry Boudet">
</head>
<body>
<h1><a name="top">libimage / marquer une image</a></h1>
<p align=center>
<tt>dernière mise à jour: 13 octobre 2013</tt><br>
<i>
<a href="http://tboudet.free.fr/libimage/img-marquage.html">#</a> et
<a href="http://la.buvette.org/devel/libimage/img-marquage.html">#</a>
</i>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-texte.html">textes</a>]
</p>
<h2>Marquer une image</h2>
<p>
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.
</p>
<dl class="proto">
<dt>int Image_marque_0(Image_Desc *img, int val);
<dd>
Trace les deux diagonales de l'image avec un gris de niveau <tt>val</tt>.
</dd>
<dt>int Image_marque_1(Image_Desc *img, char *texte, int flags);
<dd>Place un 'label' dans le coin en haut à gauche de l'image.
Les flags ne sont pas utilisés pour le moment.</dd>
<dt>int
Image_marque_timestamp(Image_Desc *img, char *texte, RGBA *rgba);
<dd>
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.
</dd>
<dt>
int Image_grille(Image_Desc *im, int stx, int ox, int sty, int oy, RGBA *ink) ;
<dd>La grille peut être habilement centrée en utilisant les offsets
<tt>ox</tt> et <tt>oy</tt>. Hélas, la composante alpha de l'encre
n'est pas prise en compte...
</dd>
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2>Marquer un rectangle</h2>
<p>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
<tt><a href="img-dessin.html#image_rect">Image_Rect</a></tt> précisément.
</p>
<dl class="proto">
<dt>int Image_gadrct_cross(Image_Desc *img, Image_Rect *rect, int k);
<dd>Tracé d'une croix en diagonale dans la zone délimitée par <tt>rect</tt>.
Le paramêtre <tt>k</tt> permettra de choisir différentes couleurs pour le fond
et la croix.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2>Fonctions connexes</h2>
<p>
Maintenant, si vous voulez construire quelques images de référence,
vous pouvez essayer les <a href="img-mires.html">quelques mires</a>
disponibles.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter,
Si votre demande est marquante, je patche comme un gruiik.<br>
<a href="http://tboudet.free.fr/cv.html">tTh.image</a><br>
</p>
</body>
</html>

69
Doc/img-mires.html Normal file
View File

@ -0,0 +1,69 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: fabriquer une mire</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, marquage, Thierry Boudet">
</head>
<body>
<h1 align=center><a name="top">libimage / fabriquer une mire</a></h1>
<p align=center>
<tt>dernière mise à jour: 7 novembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-marquage.html">marquage</a>]
</p>
<h2>Les primitives</h2>
<dl class="proto">
<dt>int Image_mirRGB_0(Image_Desc *dst, int flag);
<dd>L'image de destination doit être en 256x256. Le flag doit être
à zéro.
</dl>
<h2>The more advanced</h2>
<dl class="proto">
<dt>int Image_mircol_0(Image_Desc *dst, char *txt, int flag);
<dd>Taille de l'image: 512x512. Le texte est optionnel. Le flag
doit être à 0.
<dt>int Image_mircol_1(Image_Desc *dst, char *txt, int flag);
<dd>Taille de l'image: 512x512. Le texte est optionnel. Le flag
doit être à 0.
<dt>int Image_mircol_2(Image_Desc *dst, char *txt, int mode);
<dd>Ceci est une tentative secrète pour mettre dans une image de dimensions
données des choses que vous n'avez <b>vraiment</b> pas besoin de connaitre.
<dt>int Image_mircol_3(Image_Desc *dst, char *txt, int mode);
<dd>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.
<dt>int Image_decompose(Image_Desc *src, Image_Desc *dst, int flag);
<dd>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.
</dl>
<p>Avec un peu de chance, le <a href="img-outils.html#mires">verso</a>
de cette documentation est plus avancée. Il décrit un outil en <i>cli</i>
permettant de créer des .tga de ces mires diverses.</p>
<p class="footer">
[ <a href="http://tontonth.free.fr/cv.txt">seeking for a new job.</a> ]
</p>
</body>
</html>

62
Doc/img-op2x2.html Normal file
View File

@ -0,0 +1,62 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les blocs 2x2</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, 2x2, strange processing">
</head>
<body>
<h1><a name="top">libimage: les blocs 2x2</a></h1>
<p align=center>
<tt>dernière mise à jour: 12 novembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#liens">liens</a>]
[<a href="img-operat.html">opérations</a>]
</p>
<dl class="proto">
<dt>int Image_2x2_contours_0(Image_Desc *im);
<dd>Une opération mythique, pour moi. Mais pas vraiment facile à comprendre.
D'autant plus que cette fonction est un essai approximatif.
<dt>int Image_2x2_contours_1(Image_Desc *src, Image_Desc *dst);
<dd>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.
<dt>int Image_2x2_contrast(Image_Desc *src, Image_Desc *dst);
<dd>Alors, c'est un truc qui semble détecter les contrastes locaux, dans une
matrice 2x2, mais je ne comprends pas trop comment.
<dt>int Image_2x2_lissage(Image_Desc *src, Image_Desc *dst);
<dd>Moyenne du voisinage [0..1][0..1] des pixels de l'image.
Voir aussi les <a href="img-filtres.html">filtres</a>.
<dt>int Image_2x2_rot4pix(Image_Desc *src, Image_Desc *dst, int rot);
<dd>Rotulazionne de la imagines. A essayer, parce que moi, j'ai pas osé.
</dl>
<p>
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.
</p>
<p class="footer">
Voilà, encore du code un peu goret qui reçoit enfin un peu de documentation
+/- à jour.
</p>
</body>
</html>

67
Doc/img-operat.html Normal file
View File

@ -0,0 +1,67 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les operations</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, operations, equalize">
</head>
<body>
<h1><a name="top">libimage / les opérations</a></h1>
<p align=center>
<tt>dernière mise à jour: 27 janvier 2014</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#liens">liens</a>]
[<a href="img-op2x2.html">op 2x2</a>]
</p>
<h2>fonctions</h2>
<dl class="proto">
<dt>int Image_egalise_RGB(Image_Desc *src, Image_Desc *dst, int yo);
<dd>Ajustationnement des niveaux d'une image par la méthode des histogrammes
cumulés. le parametre 'yo' n'est pas utilise actuellement.
<dt>int Image_egalise_mono_0(Image_Desc *src, Image_Desc *dst, int yo);
<dd>Ajustements des niveaux. L'histograme cumulé est calculé sur les niveaux
de gris de l'image. Le paramètre 'yo' doir être égal à 0.
<dt>int Image_clear_component(Image_Desc *img, char component, int value);
<dd>Efface une des composante RGB à la valeur donnée.
<dt>int Image_operator(Image_Desc *in, char op, int val, Image_Desc *out);
<dd>Bon, c'est <b>la</b> fonction qui fait tout.
Sauf le café.
Les operateurs sont définis par un caractere: <tt>'+', '-', '&gt;'</tt>...
La fonction retourne <i>BAD_OPERATOR</i> si l'opérateur n'est pas connu, et
se contente alors de recopier la source dans la destination.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<p>
Bah, euh... Il y a bien les <a href="img-outils.html">outils</a> pour
quelques exemples d'utilisation.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est opérative, je patche comme un goret.<br>
</p>
</body>
</html>

134
Doc/img-patterns.html Normal file
View File

@ -0,0 +1,134 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les patterns</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, krabulator, buv3tt3, Boudet, patterns">
</head>
<body>
<h1><a name="top">libimage / les patterns</a></h1>
<p align=center>
<tt>dernière mise à jour: 12 janvier 2012</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#noise">noise</a>]
[<a href="#fill">remplissage</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Pour le moment, le mieux à faire, c'est de
'<a href="img-devel.html#utsl">utsl</a>' et de
<a href="img-outils.html#patterns">tester</a>.
</p>
<dl class="proto">
<dt>int Image_pattern_000(Image_Desc *img, int foo);
<dd> Ah, ça ne fait que du noir ?
<dt>int Image_pattern_001(Image_Desc *img, int foo);
<dd> gni ?
<dt>int Image_pattern_002(Image_Desc *img, int foo);
<dd> gni ?
<dt>int Image_pattern_003(Image_Desc *img, int foo);
<dd> C'est simple, le code n'est pas écrit.
<dt>int Image_pattern_004(Image_Desc *img, int a, int b, int c, int d);
<dd> C'est simple, le code n'est pas écrit.
<dt>int Image_pattern_005(Image_Desc *img, RGB_map *map);
<dd> gni ?
<dt>int Image_pattern_042(Image_Desc *img, RGB_map *map);
<dd>Ah, la réponse à la question universelle ssur la vie, l'univers et
le reste...
<dt>int Image_mirRGB_0(Image_Desc *dst);
<dd> gni ?
<dt>int Image_pattern_104(Image_Desc *dst, int sx, int sy, RGBA *a, RGBA *b);
<dd>Construction d'un damier.
</dl>
<p>
Une interface <a href="image77.html#patterns">fortran</a> est en préparation
et devrait être disponible fin Février 2038. D'autre part, dans le
fichier <a href="img-essais.html"><tt>essais.c</tt></a>,
il y a une fonction qui génère quelque-uns de
ces patterns. Et pour finir, une
<a href="http://la.buvette.org/images/patterns.html">page d'exemples</a>
est en préparation.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="fill">Remplissage</a></h2>
<dl class="proto">
<dt>int Image_fill_pat_0(Image_Desc *img, Image_Desc *pat, int centered);
<dd>Attention aux...
<dt>int Image_fill_pat_1(Image_Desc *img, Image_Desc *pat, int centered);
<dd>...coredumps !
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="noise">Plein de bruit</a></h2>
<p>
Remplissage d'images avec des bruits divers. Que les statisticiens me
pardonnent, mais ce que j'ai fait là est <i>un peu</i> empirique.
Disons que pour le moment, ça me permet de faire ce que je veux.
</p>
<dl class="proto">
<dt>int Image_gray_noise_0(Image_Desc *dst, int low, int high);
<dd>Gris uniforme, valeurs comprises entre low et high.
<dt>int Image_rgb_noise_0(Image_Desc *dst, int low, int high);
<dd>RGB uniforme, valeurs comprises entre low et high.
<dt>int Image_rgba_noise_0(Image_Desc *dst, int low, int high);
<dd>RGB et alpha uniforme, valeurs comprises entre low et high.
<dt>int Image_rgb_noise_1(Image_Desc *dst, RGBA *low, RGBA *high);
<dd>Bruit uniforme avec des bornes inférieures et supérieures sur chacune
des composantes.
<dt>int Image_gray_noise_2(Image_Desc *dst, int low, int high);
<dd>Algorithme du lancement de dés pour obtenir une courbe en cloche.
Mais la cloche ressemble à un pic <b>:)</b>
<dt>int Image_rgb_noise_2(Image_Desc *dst, RGBA *low, RGBA *high);
<dd>même galère pour faire la doc.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<p>
Bah, euh...
Ben non, ya <a href="http://www.lycos.fr/">presque</a> rien.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est randomatique, je patche comme un goret.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

80
Doc/img-plotters.html Normal file
View File

@ -0,0 +1,80 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les machines à plotter</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, plotting">
</head>
<body>
<h1><a name="top">libimage / les outils pour plotter</a></h1>
<p align=center>
<tt>dernière mise à jour : 4 novembre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="img-marquage.html">marquage</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Sortie, sous forme graphique, de diverses données gérés par la librairie.
Des histogrammes, des <small>COLORMAP</small>...
</p>
<h2><a name="fonctions">fonctions de base</a></h2>
<p>
En règle générale, ces fonctions génèrent des fichiers au format Targa.
</p>
<dl class="proto">
<dt>int Image_plot_histo(char *nomtga, long *hr, long *hg, long *hb, char *txt);
<dd>L'image a une taille de 400x300. Pour calculer l'histogramme, il faut
<a href="img-calculs.html#mesures">voir</a> la fonction adéquate.
<dt>int Image_calc_plot_histo(Image_Desc *img, char *tganame);
<dd>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.
<dt>int Image_plot_Map(char *nomtga, RGB_map *map , char *txt);
<dd>Dessine une palette de <a href="img-couleurs.html#couleurs">couleurs</a>
de type <a href="http://www.fractint.org/">Fractint</a>. Attention aux textes
trop longs.
<dt>int
Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte);
<dd>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.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2>Fonction avancées</h2>
<p>
Avancées, alors que ça semble plutôt être des primitives destinés à
tracer dans une image déja existante...
</p>
<dl class="proto">
<dt>int Image_plot_h_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int h);
<dd>Fabrique dans une image une petite bande horizontale à partir d'une
palette.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
Votre demande est plottante, je lance <a href="http://www.vim.org">Vim</a>,<br>
et je passe à l'action.
</p>
</body>
</html>

253
Doc/img-povhf15.html Normal file
View File

@ -0,0 +1,253 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les height_fields de POVray</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, 3d de merde, POVRAY">
</head>
<body>
<a name="top"><h1>libimage / les height_fields de POVray</h1></a>
<p align=center>
<tt>dernière mise à jour: 16 octobre 2013</tt><br>
<i>
<a href="http://tboudet.free.fr/libimage/img-povhf15.html">#</a> et
<a href="http://la.buvette.org/devel/libimage/img-povhf15.html">#</a>
</i>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#fonctions">fonctions</a>]
[<a href="#traitements">traitements</a>]
[<a href="#mixages">mixages</a>]<br>
[<a href="image77.html#povray">fortran</a>]
[<a href="#bruit">bruitage</a>]
[<a href="#synth">synthèse</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Pour savoir ce qu'est un <b>height_field</b>, consultez le site de
<a href="http://www.povray.org/">POVray</a>, et fouillez la doc.
Vous pouvez aussi en
<a href="http://krabulator.free.fr/exPOV/current/ex13.jpg">regarder un</a>
pour vous faire une idée...
</p>
<p>
En fait, un <b>height_field</b> est un &quot;champ d'altitude&quot;, 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 <a href="http://www.povray.org/">POVray</a> 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.
</p>
<a name="fonctions"><h2>fonctions de base</h2></a>
<dl class="proto">
<dt>int Image_hf15_plot(Image_Desc *im, int x, int y, int h);
<dd>Place un point de hauteur <b>h</b> (entre 0 et 32768) aux coordonnées
x et y. Les valeurs de <b>h</b> hors intervalle seront bornées.
<dt>int Image_hf15_height(Image_Desc *img, int x, int y);
<dd>Lecture de la hauteur du point aux coordonnées x et y. Cette hauteur est
automatiquement limitée à l'intervalle autorisé.
<dt>int Image_hf15_hf2gray(Image_Desc *src, Image_Desc *dst, int mode);
<dd>Conversion d'un height_field en une image en niveaux de gris. Le paramètre
<tt>mode</tt> n'est pas utilisé et doit être égal à 0.
<dt>int Image_hf15_rgb2hf(Image_Desc *src, Image_Desc *dst, int mode);
<dd>Conversion d'une image RGB en height_field. Le paramètre <tt>mode</tt>
n'est pas utilisé. On doit le mettre à 0. Cette fonction va probablement
évoluer dans un proche (ou lointain) avenir.
<dt>int Image_hf15_save_PGM(char *nom, Image_Desc *img, char *comment);
<dd>Sauvegarde un height_field en format
<a href="img-fichiers.html#pnm">PGM</a> ascii. Le suffixe recommandé
étant <tt>.pgm</tt>, mais vous faites comme vous voulez...
<i>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é.</i>
</dl>
<p align=right><a href="#top">haut de page</a></p>
<a name="traitements"><h2>traitements</h2></a>
<dl class="proto">
<dt>int
Image_hf15_lissage(Image_Desc *s, Image_Desc *d, int coef, int flag);
<dd>Lissage d'un height_field. Le paramètre <tt>coef</tt> 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.
<dt>int
Image_hf15_calc_minmax(Image_Desc *img, char *txt, int *pmin, int *pmax);
<dd>Calcul des extrèmes d'un height_field. Si <tt>txt!=NULL</tt>, un message
est affiché. Si <tt>pmin</tt> et/ou <tt>pmax</tt> sont à <tt>NULL</tt>, le
résultat correspondant n'est pas retourné. <i>ah ah, no more segfault !</i>
<dt>int
Image_hf15_normalize(Image_Desc *src, Image_Desc *dst, int min, int max);
<dd>Ajustement linéaire d'un height-field afin que toutes les valeurs
soient comprises entre <tt>min</tt> et <tt>max</tt>.
<dt>int
Image_hf15_mul_add(Image_Desc *src, Image_Desc *dst, int mul, int add);
<dd> A tester plus en détails...
<dt>int Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef);
<dd>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 <tt>coef</tt> n'est pas utilisé, il est bon de mettre 1, pour
rester compatible avec les évolutions en projet...
<dt>int Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef);
<dd>Opération inverse de la dilation: amplification des vallées. <tt>coef</tt>
n'est pas utilisé, mettre 1.
<dt>int Image_hf15_mult_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
<dd>Multiplication de deux height-fields, avec remise à l'échelle pour ne
pas faire de dépassements. Pas trop testé ;(
<dt>int Image_hf15_sqrt(Image_Desc *src, Image_Desc *dst);
<dd>Racine carré normalisée de l'altitude normalisée. Peu testée, mais
visuellement prometteuse.
<dt>int
Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double p0w44)
<dd>En quelque sorte la fonction complémentaire de la racine carré. Et là aussi
on opère sur des valeurs normalisées.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<a name="mixages"><h2>mixages</h2></a>
<p>
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
<a href="http://foo.buvette.org/bf/hf/">début de démonstration</a>
qui donne parfois de bonnes idées bien mouvantes.
</p>
<dl class="proto">
<dt>int
Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int k);
<dd> Mélange de deux HF. Le coefficient <tt>k</tt> 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.
<dt>int
Image_hf15_mult(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst);
<dd>
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
<a href="mailto:oulala@chez.com">signe</a>.
<dt>int Image_hf15_getmin(Image_Desc *s1, Image_Desc *s2, Image_Desc *d);
<dd>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 <tt>Image_hf15_getmax</tt> dont la sémantique est évidente.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<a name="bruit"><h2>bruitages</h2></a>
<dl class="proto">
<dt>int Image_hf15_noise_0(Image_Desc *dst, int hi, int lo, int pr100);
<dd>Avec une probabilité de <tt>(pr100 % 100)</tt>, l'altitude sera mise entre
<tt>hi</tt> et <tt>lo</tt> pour tout les points de l'image.
<dt>int Image_hf15_noise_1(Image_Desc *dst, int mo, int of, int pr100);
<dd>Cette fonction déplace une atltitude de 'mo' avec un offset de 'of'.
Le paramètre 'pr100' n'est pas utilisé.
<dt>int Image_hf15_noise_2(Image_Desc *dst, int pr100, int di, int k1, int k2);
<dd>Remplacement aléatoire du point courant par un de ses proches voisins.
Le code n'est hélas pas encore vraiment optimisé.
<dt>int Image_hf15_noise_3(Image_Desc *dst, double coef, int flag);
<dd>Léger bruitage proportionnel à la hauteur du point concerné. Cette fonction
a été inventée pour la montagne de
<a href="http://foo.buvette.org/bf/pm/sonia.avi">Sonia</a>.
</dl>
<a name="synth"><h2>Synthèses</h2></a>
<p>
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.
</p>
<dl class="proto">
<dt>int Image_hf15_synth_0(Image_Desc *dst, Image_PtList *ptl);
<dd>Pas très fini, en cours de démoulage. Et vous ne savez pas ce qu'est
une <i>PtList</i> ? Voici un petit <a href="img-ptlist.html">topo</a>.
<dt>int Image_hf15_synth_fromfunc0(Image_Desc *dst, int k,
double(*func)(int x, int y, int k))
<dd>Vous avez sous la main une fonction du genre <tt>h = func(x, y)</tt> ?
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 <i>dynamique</i>
complète du hf.
</dl>
<p align=right><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<ul>
<li>Il existe une <a href="image77.html#povray">interface G77</a> pour
ces fonctions.
<li><a href="http://www.povray.org/">POVray</a>, and have a look at the new
3.5 version...
<li><a href="http://pov.monde.free.fr/">Pov Monde</a> les POVeurs francophones.
<li><a href="http://tontonth.free.fr/pov/">tTh</a> fait quelques raytracings.
<li>Comment faire des <a href="img-stereo.html">images en relief</a>.
<li>un début de <a href="http://tontonth.free.fr/pov/hf/">howto</a> pour faire
des images avec les hf15s.
<li>Il y a d'autres choses étranges dans POV: les
<a href="img-df3.html">df3</a> (<i>aka</i> density files) en font partie.
</ul>
<p>
Dans un autre domaine <i>povesque</i>, si vous créez deux images en déplaçant
légerement le point de vue, vous pouvez les
<a href="img-stereo.html">combiner</a> en une image, que vous verrez en
relief avec une paire de lunettes munie des
<a href="img-stereo.html#filtres">filtres</a> adéquats.
</p>
<p align=right><a href="#top">haut de page</a></p>
<p class="footer">
Votre demande est traçante,
<a href="http://foo.bar.quux.over-blog.com/">je</a> lance mon
<a href="http://www.vim.org">Vim</a>,<br>
et je passe à l'action altitudisante.
</p>
</body>
</html>

104
Doc/img-ptlist.html Normal file
View File

@ -0,0 +1,104 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les listes de points</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, liste de points">
</head>
<body>
<h1>libimage: les listes de points</h1>
<p align=center>
<tt>dernière mise à jour: 15 octobre 2013</tt><br>
</p>
<p>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.
</p>
<h2>Un point et une liste de points, c'est quoi ?</h2>
<p>
Comme un point se réfère à une image, il va forcément avoir les
coordonnées d'un pixel, donc un tuple <tt>x,y</tt>. Ensuite, nous avons
deux attributs: le premier est assimilable à la &quot;hauteur&quot; 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
<small>LUT</small> 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é.
</p>
<pre class=code>
typedef struct
{
short x, y; /* pixel position */
short h; /* pixel value */
short c; /* color index ? */
} Image_Point;
</pre>
<p>
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.
</p>
<h2>Fonctions de bases</h2>
<dl class="proto">
<dt>Image_PtList * Image_ptl_alloc(int nbre, char *name);
<dd>Allocation d'une liste de points. <tt>nbre</tt> étant le nombre
de points initialement alloués et <tt>name</tt> un texte arbitraire
d'une taille limitée. La taille est dynamique, c'est à dire qu'une liste
de points peut grossir à la demande.
<dt>int Image_ptl_kill(Image_PtList *ptl, char *msg);
<dd>Destruction d'une liste et probable récupération de la mémoire
utilisée. Si <tt>NULL != msg</tt>, un message est éventuellement
affiché sur stderr.
<dt>int Image_ptl_get_size(Image_PtList *ptl, int *nbre, int *alloc);
<dd>Récupère le nombre de points effectif dans la liste, et la place
disponible actuelle. On peut passer <tt>NULL</tt> si on ne veut pas
récupérer une des valeurs.
<dt>int Image_ptl_add(Image_PtList *ptl, int x, int y, int h, int c);
<dd>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 <small>OOMK</small> farceur. Il n'est
actuellement pas possible d'enlever un point de la liste.
<dt>int Image_ptl_get(Image_PtList *ptl, Image_Point *pt, int idx);
<dd>Lecture d'un point depuis une liste. Coredumpe peut-être,
mais pas trop souvent.
<dt>int Image_ptl_boundingbox(Image_PtList *ptl, Image_Rect *box);
<dd>Calcul de la boite qui englobe en x/y tous les points d'une liste.
Il traine probablement une <i>off-by-one</i> erreur dans le code.
Utilisez <a href="libimage.html#tools">Image_dump_rect</a> pour afficher
le résultat.
</dl>
<p>
On peut, bien entendu, mettre ces listes de points dans des
<a href="img-fichiers.html#ptl">fichiers</a>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
</body>
</html>

94
Doc/img-showdiff.html Normal file
View File

@ -0,0 +1,94 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: montrer les differences</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, krabulator, Boudet, Targa, hexdiff">
</head>
<body>
<a name="top"><h1>libimage / montrer les différences</h1></a>
<p align=center>
<tt>dernière mise à jour: 20 janvier 2014</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html#primitives">primitives</a>]
[<a href="#liens">liens</a>]
[<a href="img-outils.html">outils</a>]
</p>
<p>
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 <a href="img-combine.html">combinations</a> d'images.
</p>
<dl class="proto">
<dt>int Image_showdiff_0(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst)</tt>
<dd>Pour chacune des composantes, la valeur est calculée ainsi:
<tt>v = ((v1 - v2)/2) + 127</tt>.
<dt>int
Image_showdiff_1(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst, int dmin)</tt>
<dd>Completement binaire sur les trois composantes. En pseudo-code, ça donne
à peu près ceci:
<pre>
for component in (r, g, b)
if component(im1)&gt;component(im2)
then pix=component.255
else pix=component.0
end for
</pre>
<dt>int
Image_showdiff_2(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst, int dmin)</tt>
<dd> cette fonction n'est pas vraiment finie...
<dt>int
Image_showdiff_3(Image_Desc *im1, Image_Desc *im2, Image_Desc *dst,
int kr, int kg, int kb)</tt>
<dd>Algo:
<pre>
pour chaque composante
si delta(im1.C, im2.C) &lt; kC
dst.C = 96
sinon
dst.C = 255
</pre>
</dl>
<p>
Il existe plein d'autres façons de comparer deux images, et
je vous laisse le soin de les imaginer...
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
L'habituelle rubrique des liens, toujours complètement vide.
Rattrapez vous <a href="libimage.html#liens">ici</a> ou
<a href="img-outils.html#showdiff">là</a>.
</p>
<hr>
<p align=right>
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est différentielle,<br>je patche comme un goret.<br>
<a href="#top">haut de page</a></p>
<p align=center><a href="http://tboudet.free.fr/hexdiff/">tTh is the king of diff</a></p>
</body>
</html>

95
Doc/img-stereo.html Normal file
View File

@ -0,0 +1,95 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: la stéréo</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, relief, stéréo, POVray, Boudet">
</head>
<body>
<h1><a name="top">libimage / la stéréo</a></h1>
<p align=center>
<tt>dernière mise à jour: 20 octobre 2013</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#liens">liens</a>]
</p>
<p>
Le principe est simple: Avec <i>POV</i>, 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.
</p>
<p>
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
<a href="http://la.buvette.org/POV/stereo.html"><small>HOWTO</small></a>
avec une vidéo en troisD.
</p>
<p>Voyons maintenant les fonctions qui existent...</p>
<dl class="proto">
<dt>int Image_combine_stereo_0(Image_Desc *gauche, Image_Desc *droite,
Image_Desc *stereo);
<dd>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.
<dt>int Image_combine_stereo_1(Image_Desc *gauche, Image_Desc *droite,
Image_Desc *stereo, int kr, int kg, int kb);
<dd>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.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="filtres">filtres</a></h2>
<p>
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
&quot;repas enfant&quot; du McDo. A vous de trouvez les votres...
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="liens">liens</a></h2>
<p>
Bah, euh... Avec un peu de chance, vous trouverez un exemple
dans <a href="http://tontonth.free.fr/pov/hf/">ça</a>, mais ce ne
sera peut-être pas très clair.
Une explication un peu plus
<a href="http://la.buvette.org/POV/stereo-2.html">détaillée</a>
a été écrite en anglais de cuisine.
Il existe aussi quelques fonctions
pour traiter les <a href="img-povhf15.html">height fields</a>
de Povray. Et d'autres méthodes de
combinaisons d'images
<a href="img-combine.html">là</a>.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est en relief, je patche comme un Spleyt.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

78
Doc/img-television.html Normal file
View File

@ -0,0 +1,78 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: effets television</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libtthimage, krabulator, television">
</head>
<body>
<a name="top"><h1>libimage / effets télévision</h1></a>
<p align=center>
<tt>dernière mise à jour: 27 janvier 2014</tt><br>
</p>
<p>
Voici quelques autres <a href="img-effets.html">effets</a>
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.
</p>
<dl class="proto">
<dt>int
Image_TV_grink(Image_Desc *src, Image_Desc *dst, int yo);
<dd>?
<dt>int
Image_TV_grok(Image_Desc *src, Image_Desc *dst, int yo);
<dd>?
<dt>int
Image_TV_gruud(Image_Desc *src, Image_Desc *dst, int yo);
<dd>Pour le moment, le paramètre ne sert à rien et doit être mis à 0.
<dt>int
Image_TV_griiiz(Image_Desc *src, Image_Desc *dst, int yo);
<dd>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.
<dt>int
Image_TV_veryold(Image_Desc *src, Image_Desc *dst, int p1, int p2, int p3);
<dd>Je ne sais pas à quoi servent les paramètres, mais ils ne doivent
pas être trop petits.
<dt>int
Image_TV_pix_0(Image_Desc *src, Image_Desc *dst, int w, int h, int grey);
<dd>Pixelisation rectangulaire (w * h) avec un fond 'grey' entres les
gros pixels.
<dt>
int Image_TV_cplus_proto(Image_Desc *src, Image_Desc *dst, int p);
<dd>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.
</dl>
<p>
Pour essayer d'y voir plus clair dans mes simulations d'écran de
vieilles télévisions, il y a une page de
<a href="http://la.buvette.org/images/television.html">démonstration</a>
utilisant l'outil adéquat.
Tout pour me donner l'envie d'aller plus loin dans ce domaine.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class=footer>
[ <a href="http://tboudet.free.fr/cv.html">tTh dessine</a> ]
</p>
</body>
</html>

221
Doc/img-texte.html Normal file
View File

@ -0,0 +1,221 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les textes</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, fontes bitmap, truetype">
</head>
<body>
<a name="top"><h1 align=center>libimage / les textes</h1></a>
<p align=center>
<tt>dernière mise à jour: 14 décembre 2015</tt><br>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#16x24">16 x 24</a>]
[<a href="#gropixels">gropixels</a>]
[<a href="#outils">outils</a>]
[<a href="img-asciiart.html">ascii art</a>]
[<a href="#liens">liens</a>]
</p>
<h2><a name="fontes">Fontes internes</a></h2>
<p>
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 <a href="image77.html#textes">f77</a> n'est pas plus complète.
</p>
<p><b>Attention !!!</b> 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. <i>Hélas, espoir déçu, j'ai un bronx infernal dans
plein de trucs...</i>
</p>
<p>Dans le tarball, il y a deux fontes 8x8 nommée <tt>libimage.fonte</tt>
et <tt>8x8thin</tt>.
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...</p>
<center><img src="all8x8chars.png"></center>
<dl class="proto">
<dt>int Image_load_fnt8x8(char *nomfnt, U_BYTE *ou, int flags);
<dd>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 <tt>ou</tt> et <tt>flags</tt> sont inutilisés
pour le moment. Si le nom du fichier fonte est NULL, une fonte par défaut
sera utilisée.
<dt>int Image_trace_caractere(Image_Desc *im, int x, int y, int code);
<dd>Cette fonction est très primitive. Elle trace en <i>noir</i> sur un
fond <i>blanc</i> en utilisant la fonte courante.
<dt>int Image_trace_chaine_0(Image_Desc *im, char *txt, int x, int y,
RGBA *paper, RGBA *ink, int flags);
<dd>Bah, pas grand chose à dire, à part que le paramètre 'flags' doit
être mis à zéro,
et que cette fonction est <i>obsolète</i>, et l'exprime clairement.
<dt>int Image_trace_chaine_1(Image_Desc *im, char *txt, int x, int y,
char *nomfonte, RGBA *paper, RGBA *ink);
<dd>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 <tt>NULL</tt>, c'est la dernière fonte
chargée qui sera utilisée.
<dt>int Image_texte_fonte(char *nomfonte, char *nomtga);
<dd>Donc voilà le kludge. La seule valeur humainement supportable
pour le paramètre <i>nomfonte</i>, c'est <tt>NULL</tt> et les insultes
parce que <font color="orange">çamarchpa</font>, c'est pour moi.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="16x24"><h2>fonte 16 x 24</h2></a>
<p>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 <tt>awk</tt>. Ce fichier est une suite
d'enregistrements contenant le code ascii du caractère considéré, suivi
de 24 lignes contenant les pixels. Exemple:
</p>
<pre class="code">
60
................
................
................
..........**....
.........***....
........**......
.......**.......
......**........
.....**.........
....**..........
...**...........
..***...........
...**...........
....**..........
.....**.........
......**........
.......**.......
........**......
.........***....
..........**....
................
................
................
................
</pre>
<p>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.
</p>
<dl class="proto">
<dt>int Image_t16x24_txtload(char *fontname, U_BYTE *zone, int flag);
<dd>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 <tt>flag</tt> à 1 demande
l'effacement préalable de cette zone statique.
<dt>int Image_t16x24_pltch_exp(Image_Desc *img, int lettre, int xpos, int ypos);
<dd>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.
<dt>int Image_t16x24_pltch_1(Image_Desc *img, int lettre, int xpos, int ypos,
RGBA *pap, RGBA *ink, int flags);
<dd>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. <tt>flags</tt>
doit être mis à 0. Aucun contrôle de débordement n'est fait.
<dt>int Image_t16x24_allchars(char *fontname, char *tganame, int flag);
<dd>Construction d'une image contenant le dessin des 256 caractères.
</dl>
<p>Voilà, c'est tout pour le moment, mais ça permet déja de faire des
choses. Je continue à réfléchir aux nouveaux <i>features</i> que je
vais pouvoir inventer. Restez à l'écoute...
</p>
<center><img src="all16x24chars.png"></center>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="outils"><h2>outils 16 x 24</h2></a>
<p>
Hop, hop, quelques trucs supplémentaires. Dans le
<a href="libimage.tar.gz">tarball</a>, vous trouvererez <tt>fnt8to16</tt> 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.<p>
<center><img src="bigthin.gif" width=488 height=181></center>
<p>Dans le tarball vous trouverez la fonte ci-dessus (fichier
<tt>16x24thin</tt>) qui sera installé comme les autres fontes.
Dans les
<a href="img-outils.html#mires">outils associés</a>,
le programme <tt>tga_mires</tt> peut maintenant tracer le contenu d'une
fonte 16x24, modulo le parsage des paramètres de la ligne de commande.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="gropixels">texte en 'gropixels'</a></h2>
<p>Une nouveauté de 2014 (codenamed: <i>rouille de seiche</i>)
encore très immature. Ces fonctions utilisent les
<a href="#fontes">fontes</a> 8x8 mise aux échelles en X et en Y,
sans interpolation, d'où le nom de <b>gropixels</b>.
</p>
<dl class="proto">
<dt>int Image_trace_big_char_0(Image_Desc *im,
int x, int y, int code, int kx, int ky);
<dd>Première version du tracé de caractère 'gropixels'.
Les paramètres <tt>kx</tt> et <tt>ky</tt> sont les coefficients de
mise à l'échelle. Il est nécessaire d'avoir préalablement chargé
une fonte avec <tt>Image_load_fnt8x8</tt>.
<dt>int Image_txt1_big_0(Image_Desc *im, char *txt, int x, int y,
int xf, int yf);
<dd>Première version du tracé de chaine en 'gropixels'. Hélas, pas
de contrôle des limites, donc coredump presque assuré.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
Bah, euh... <a href="http://www.freetype.org/">Freetype</a>, par exemple.
Mais je suis aussi à la recherche d'un format de fontes 'bitmap' évolué,
bien documenté et disposant d'un éditeur sous <b>X11</b> facile
d'utilisation.
</p>
<p class="footer">
<b>tTh</b>, éleveur de police depuis 1998...<br>
Toujours à la recherche de trucs à faire dans le domaine
de l'ascii-art...<br>
<a href="#top">haut de page</a></p>
</body>
</html>

88
Doc/img-warp.html Normal file
View File

@ -0,0 +1,88 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: les warps</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, Boudet, warps, interpolate">
</head>
<body>
<a name="top"><h1 align=center>libimage / les warps</h1></a>
<p align=center>
<tt>dernière mise à jour: 30 janvier 2009</tt><br>
<i>
<a href="http://tboudet.free.fr/libimage/img-warp.html">#</a> et
<a href="http://la.buvette.org/devel/libimage/img-warp.html">#</a>
</i>
</p>
<p class="menuhaut">
[<a href="libimage.html">libimage</a>]
[<a href="#interpolate">interpolate</a>]
[<a href="#liens">liens</a>]
</p>
<p>
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 <a href="img-devel.html#utsl">utsl</a>.
</p>
<dl class="proto">
<dt>
int Image_center_rotate(Image_Desc *src, Image_Desc *dst, double angle);
<dd>rotulationne de la image. L'angle est exprimé en degrés. L'interpolation
est foireuse.
<dt>
int Image_shift_xy(Image_Desc *src, Image_Desc *dst, int ox, int oy);
<dd>Déplacement de l'image en X et Y. J'ai l'impression que ça ne marche pas
si les offsets sont négatifs...
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="interpolate"><h2>interpolate</h2></a>
<p>
<tt>/O\ <i>oh ma tête...</i></tt>
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<a name="zoom"><h2>zoom</h2></a>
<p>
<tt>/O\ <i>oh ma tête...</i></tt>
</p>
<dl class="proto">
<dt>int Image_essai_zoom(Image_Desc *src, Image_Desc *dst, int kx, int ky, int flags)
<dd>Fonction à prototype fluctuant destiné à essayer des trucs et
des machins zoomants.
</dl>
<p class="HDP"<a href="#top">haut de page</a></p>
<a name="liens"><h2>liens</h2></a>
<p>
Bah, euh... Non, rien...
</p>
<ul>
<li>
<a href="http://astronomy.swin.edu.au/~pbourke/colour/bicubic/">Interpolation Bicubique</a>
</ul>
<p class="HDP"><a href="#top">haut de page</a></p>
<p class="footer">
vous pouvez me contacter:<br>
<a href="mailto:oulala@chez.com">oulala@chez.com</a><br>
Si votre demande est interpolée, je patche comme un gruik.<br>
<a href="#top">haut de page</a></p>
</body>
</html>

78
Doc/libimage.css Normal file
View File

@ -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; }

241
Doc/libimage.html Normal file
View File

@ -0,0 +1,241 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>libimage: la doc, enfin !</title>
<link rel="stylesheet" type="text/css" href="libimage.css">
<meta name="generator" content="Vim et huile de phalange">
<meta name="keywords" content="libimage, oulala, buv3tt3, Boudet, Targa">
</head>
<body>
<h1><a name="top">Libimage : <i>La Doc</i></a></h1>
<p align=center>
<tt>dernière mise à jour : 15 décembre 2015</tt><br>
</p>
<p class=menuhaut>
[<a href="#primitives">primitives</a>]
[<a href="README.txt">README</a>]
[<a href="img-fichiers.html">fichiers</a>]
[<a href="#tools">tools</a>]
[<a href="img-cadres.html">cadres</a>]
<br>
[<a href="img-effets.html#effets">effets</a>]
[<a href="img-op2x2.html">op2x2</a>]
[<a href="img-texte.html">texte</a>]
[<a href="img-showdiff.html">showdiff</a>]
<br>
[<a href="img-filtres.html">filtres</a>]
[<a href="img-calculs.html">calculs</a>]
[<a href="img-plotters.html">plotteurs</a>]
[<a href="#scale">scale</a>]
<br>
[<a href="img-combine.html">combine</a>]
[<a href="img-patterns.html">patterns</a>]
[<a href="img-couleurs.html#couleurs">couleurs</a>]
[<a href="img-couleurs.html#palettes">palettes</a>]
<br>
[<a href="img-dither.html">dithering</a>]
[<a href="img-operat.html">opérations</a>]
[<a href="img-alpha.html">alpha</a>]
[<a href="img-povhf15.html">hf 15</a>]
[<a href="img-bitplane.html">bitplane</a>]
<br>
[<a href="image77.html">fortran</a>]
[<a href="img-df3.html">density file</a>]
[<a href="#messages">messages</a>]
[<a href="img-exemples.html">exemples</a>]
[<a href="#liens">liens</a>]
</p>
<p>
<b>libimage</b> est une librairie de traitement de les images que j'ai
fabriquée moi-même avec mon
<a href="http://www.vim.org/"><tt>vim</tt></a> et mes
<a href="http://gcc.gnu.org/"><tt>gcc &amp; g77</tt></a> tout seul
comme un grand. Tout n'est pas documenté, loin de là, seulement les fonctions
que j'utilise actuellement. Par contre, la
<a href="img-devel.html#compilation">procédure d'installation</a> est à peu
près explicite.
</p>
<p>
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
<a href="libimage.tar.gz">sources</a>
à votre disposition.
<a href="img-devel.html#utsl">utsl</a>.
Il existe aussi quelques <a href="#exemples">exemples</a> d'utilisation
dans la vie réelle.
</p>
<h2><a name="primitives">primitives</a></h2>
<dl class="proto">
<dt>Image_Desc * Image_alloc(int w, int h, int type)
<dd>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... <b>!!!</b> le contenu de l'image n'est
pas initialisé. Son contenu est allé à Toire. Il faut utiliser
<tt>Image_clear</tt> pour l'effacer.
<dt>int Image_DeAllocate(Image_Desc *)
<dd>Restitution de la mémoire 'pixel' d'une image. Attention, la mémoire
du descripteur n'est <b>pas</b> rendue. C'est probablement un
<a href="img-devel.html#bugs">bug</a>.
<dt>Image_Desc * Image_clone(Image_Desc *i, int copie)
<dd>Crée une copie d'une image de même type. Si le flag <tt>copie</tt> est
<small>TRUE</small>, les pixels sont recopiés dans la nouvelle image.
<dt>int Image_clear( Image_Desc *image, int r, int g, int b)
<dd>Remplissage d'une image avec les <i>rgb</i> fournis.
<i>28 Déc 2001</i>: si un canal alpha est présent, il est mis à 0.
<dt>int Image_plotRGB(Image_Desc *i, int x, int y, int r, int g, int b)
<dd>Ecrire un pixel dans une image, avec vérification des limites.
<dt>int Image_plot_channel(Image_Desc *img, char channel, int x, int y, int value)
<dd>Cette fonction permet de modifier un seul des canaux de l'image.
Le paramètre 'channel' est un <tt>char</tt> 'r', 'g', 'b', 'R', 'G' ou 'B'.
Le canal <i>alpha</i> n'est pas encore géré.
<dt>int Image_getRGB(Image_Desc *i, int x, int y, int *pr, int *pg, int *pb)
<dd>Lecture d'un pixel. En rajoutant un 'A' au nom de la fonction, et un
quatrième pointeur sur <tt>int</tt>, on peut aussi lire le canal
<a href="img-alpha.html">alpha</a>.
<dt>Image_print_version(int flag)
<dd>Affiche sur <tt>stdout</tt> la version de la librairie. Si <tt>flag</tt>
est != 0, il y a des informations complémentaires. Si flag &gt; 1 certaines
options de compilation et/ou d'installation sont aussi affichées.
Vous disposez également d'un <tt>#define IMAGE_VERSION_STRING</tt>
utilisable dans un
<i>printf ("version %s\n", IMAGE_VERSION_STRING);</i> de bon aloi.
Attention quand même, si vous utilisez ce <tt>#define</tt> dans un programme
lié avec la bibliothèque dynamique, <i>puis</i> que vous passiez à une
version différente de la libimage, la version affichée par votre programme
ne sera plus cohérente.<br>
Pour un rapport de bug, le numéro de version est <b>indispensable</b>.
C'est auprès de <a href="mailto:oulala@chez.com">moi</a> qu'il faut raler.
</dl>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="tools">tools</a></h2>
<p>
Différentes routines utilitaires, destinées avant tout à la mise au point
des applications, mais qui ne sont pas interdites aux <i>péones</i>, loin
de là.
</p>
<dl class="proto">
<dt>int Image_dump_descriptor(Image_Desc *im, char *text);
<dd>Affiche, de façon désordonnée, les informations disséminées dans un
descripteur d'image <i>Image_desc</i>.
<dt>int Image_dump_rect(Image_Rect *rect, char *texte, int flag);
<dd>Affiche le contenu d'une structure Image_Rect. Un flag différent de
zéro rajoute l'autre coin (<i>pan</i>) et la surface.
<dt>int Image_fabrique_une_mire(Image_Desc *im, RGB_map *map);
<dd>Euh, ça devrait en principe marcher avec une image 320x200.
Il existe d'autres <a href="img-mires.html">mires</a> dans le truc.
<dt>Les chronomètres:</dt>
<dd>On dispose de 42 chronomètres. Etonnant, non?<br>
<tt>void Image_start_chrono(char *texte, int num_chrono);</tt><br>
<tt>long Image_stop_chrono(char *texte, int num_chrono);</tt><br>
Maintenant, comment les utiliser avec précision et certitude est un exercice
laissé à nos lecteurs... Sans compter que certains sont réservés par tTh.</dd>
</dl>
<p>
Il y a aussi, dans le genre relativement utile,
le <a href="img-marquage.html">marquage</a> des images.
</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="messages">messages</a></h2>
<p>
A la lecture du fichier <tt>tthimage.h</tt> vous avez constaté une série de #define
pour les codes d'erreur. La fonction <tt>char * Image_err2str(int codeerr)</tt>
permet d'obtenir un texte explicatif. Vous pouvez par exemple écrire:
</p>
<pre class="code">
foo = Image_blabla(gniark);
printf(&quot;retour from hell: %s\n&quot;, Image_err2str(foo));
</pre>
<dl class="proto">
<dt>char * Image_err2str(int codeerr);
<dd>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.
<dt>void Image_print_error(char * texte, int err);
<dd>Affichage d'un message décrivant une erreur. Si le texte commence par
le caractère '-', c'est sur <i>stdout</i>, sinon, c'est sur <i>stderr</i>.
Les numéros d'erreur sont à décrypter dans <tt>tthimage.h</tt>.
</dl>
<p>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.</p>
<p class="HDP"><a href="#top">haut de page</a></p>
<h2><a name="exemples">exemples</a></h2>
<ul>
<li>J'ai <i>enfin</i> confectionné quelques
<a href="img-outils.html">utilitaires</a> pour la ligne de
commande qui appellent des primitives de la librairie. Ils sont
<a href="img-outils.tar.gz">ici</a> et
je vous invite à en lire les sources. C'est un bon point de départ pour
apprendre à utiliser le bidule.
<li>Le postprocessing des images des
<i>Sources de Tar</i> a été
fait avec libimage: combinaison de deux variantes de l'image faite par
POV et divers effets de cadres.
</ul>
<p>
En conclusion, vous êtes livré à vous-même avec ce kludge, mais j'espère
que vous trouverez autant de <i>fun</i> à l'utiliser que j'en ai à le faire.
Et je vous rappelle que ce logiciel est diffusé sous la bienveillante
protection de la <b>DMZIZ licence</b> que vous pouvez trouver
<a href="http://la.buvette.org/textes/dmdzz.html">par là</a>.
</p>
<h2><a name="liens">liens</a></h2>
<ul>
<li>Pour les fous de la fabrication d'images:
<a href="http://www.povray.org/">Povray</a> et
<a href="http://www.fractint.org/">Fractint</a>.
<li>Pour les cinglés de la manipulation d'image:
<a href="http://www.gimp.org/">Gimp</a> qui roulaize grave pour les
clicketeurs, et <a href="http://www.imagemagick.org/">image-magick</a>
pour les batcheurs.
</ul>
<p class="footer">
vous pouvez me contacter sur IRC : <tt>tth@freenode#tetalab</tt> <br>
Si votre demande est raisonnable, je patche à donf.<br>
</p>
</body>
</html>

6
README.md
View File

@ -1,6 +1,10 @@
# libtthimage # 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 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. Il a pour but de brotcher les images avec vigueur.

12
foo.c Normal file
View File

@ -0,0 +1,12 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include "tthimage.h"
int main(int argc, char *argv[])
{
Image_print_version(2);
return 0;
}

595
image.c Normal file
View File

@ -0,0 +1,595 @@
/*
fonctions de bases pour la librairie 'libimage'
-----------------------------------------------
(g) 1992,2003 - Thierry Boudet - aka Oulala
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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<h; foo++)
{
if ((ptr=(unsigned char *)malloc(sizeof(unsigned char) * w))==NULL)
{
fprintf(stderr, "%s: malloc failed for image line %d\n", __func__, foo);
exit(1);
}
*lignes++ = ptr;
}
return 0;
}
/*::------------------------------------------------------------------::*/
/*
* This function allocate an image and return a pointer
* on the structure who describe the image.
* - - - > 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; y<image->height; y++)
{
/*
* XXX here we can go faster with a few memset
*/
for (x=0; x<image->width; 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; y<image->height; y++)
{
for (x=0; x<image->width; 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; line<im->height; line++)
if (im->Rpix[line] != NULL) free(im->Rpix[line]);
free(im->Rpix); im->Rpix = NULL;
}
if (im->Gpix != NULL)
{
for (line=0; line<im->height; line++)
if (im->Gpix[line] != NULL) free(im->Gpix[line]);
free(im->Gpix); im->Gpix = NULL;
}
if (im->Bpix != NULL)
{
for (line=0; line<im->height; line++)
if (im->Bpix[line] != NULL) free(im->Bpix[line]);
free(im->Bpix); im->Bpix = NULL;
}
if (im->Apix != NULL)
{
for (line=0; line<im->height; 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;
}
/*::------------------------------------------------------------------::*/

1383
tthimage.h Normal file
View File

File diff suppressed because it is too large Load Diff