hop, le premier bug
This commit is contained in:
tth
parent
fc17a4c260
commit
e795f8a5bf
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>& .o*O&</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>
|
||||
|
|
@ -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>
|
||||
|
||||
|
|
@ -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>
|
||||
|
|
@ -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 "calculs" 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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>"remappe" 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>&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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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, "");</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>
|
||||
|
|
@ -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 <0,0,0> to <1,1,1> The data file is a raw binary
|
||||
file format created for POV-Ray called df3 format. The syntax provides
|
||||
for the possibility of implementing other formats in the future. This
|
||||
pattern was originally created for use with halo or media but it may
|
||||
be used anywhere any pattern may be used.
|
||||
</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 & 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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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> & <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 "effets spéciaux" 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 "tuiles" 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>
|
||||
|
|
@ -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 "/tmp/pattern" 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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>'+', '-', '>'</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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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 "champ d'altitude", une
|
||||
sorte de matrice à deux dimensions dont chaque cellule représente une hauteur.
|
||||
Cette hauteur est un nombre codé sur 15 bits, donc entre 0 et 32767.
|
||||
Les gens de <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>
|
||||
|
|
@ -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 "hauteur" de
|
||||
ce point dans le champ virtuel du monde pixelisé, et le second
|
||||
est laissé à l'imagination du codeur (pourquoi pas un index dans une
|
||||
<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>
|
||||
|
||||
|
|
@ -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)>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) < 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>
|
||||
|
|
@ -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
|
||||
"repas enfant" 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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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>
|
||||
|
|
@ -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; }
|
||||
|
||||
|
|
@ -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 & 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 > 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("retour from hell: %s\n", 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>
|
||||
12
README.md
12
README.md
|
|
@ -1,6 +1,10 @@
|
|||
# libtthimage
|
||||
|
||||
Du code né dans les années 1986 sur un Kenitec 286 sous msdos 4 ou 5, qui s'est un jour retrouvé dans un Linux (kernel 0.99) et qui végète depuis ~2005
|
||||
|
||||
Il a pour but de brotcher les images avec vigueur.
|
||||
|
||||
Du code né dans les années 1986 sur un Kenitec 286 sous msdos 4 ou 5,
|
||||
qui s'est un jour retrouvé dans un Linux (kernel 0.99) et qui végète
|
||||
depuis ~2005. Il est venu le temps de le remettre en route.
|
||||
|
||||
Il a pour but de brotcher les images avec vigueur.
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue