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

cosmetic

Browse Source
This commit is contained in:
tTh 2022-10-28 05:07:32 +02:00
parent 63b0bce081
commit ca9947e7cc
14 changed files with 148 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Lib/alpha.c
View File

@ -7,8 +7,9 @@
Et c,a va me forcer a installer libpng Et c,a va me forcer a installer libpng
-------------------------------------- --------------------------------------
15May01: on attend toujours libPNG 15May01: on attend toujours libPNG
07Dec01: pfeue, libPNG toujours pas là... 07Dec01: pfeue, libPNG toujours pas la...
03Fev14: ... please wait more ... 03Fev14: ... please wait more ...
04Oct22: on the way, stay tuned.
*/ */
#include <stdio.h> #include <stdio.h>

12
Lib/basic_io.c
View File

@ -2,17 +2,17 @@
BASIC_IO Sept 2001 BASIC_IO Sept 2001
-------- --------- -------- ---------
Ce module a été écrit pour tenter de régler les Ce module a ete ecrit pour tenter de regler les
problèmes de "boutisme" pour que ça puisse aussi problemes de "boutisme" pour que c,a puisse aussi
tourner sur les vrais processeurs, parce que, bon, tourner sur les vrais processeurs, parce que, bon,
les 386, ça suffit, hein... les 386, parfois, on s'en gave, hein...
Ceci dit, je ne sais pas vraiment comment traiter Ceci dit, je ne sais pas vraiment comment traiter
le problème. Pour le moment (Septembre 2001) c'est le probleme. Pour le moment (Septembre 2001) c'est
un peu beaucoup du "try and test". un peu beaucoup du "try and test".
D'autre part, comment ça va se passer sur des CPUs D'autre part, comment les choses vont se passer sur
à 64 (ou 128) bits ? des CPUs a 64 (ou 128) bits ?
------------------------------------------------- -------------------------------------------------
9 oct 2001: pourquoi pas de fonction pour ecrire des BYTEs ? 9 oct 2001: pourquoi pas de fonction pour ecrire des BYTEs ?

25
Lib/col4bits.c
View File

@ -11,8 +11,7 @@
#include "../tthimage.h" #include "../tthimage.h"
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
int int Image_col4bits_and(Image_Desc *src, Image_Desc *dst)
Image_col4bits_and(Image_Desc *src, Image_Desc *dst)
{ {
int foo; int foo;
@ -69,8 +68,7 @@ return ( (r1+g1+b1) - (r2+g2+b2) );
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
#define TAILLE (1<<12) #define TAILLE (1<<12)
int int Image_calc_Map_4bits(Image_Desc *img, RGB_map *map, int nbre)
Image_calc_Map_4bits(Image_Desc *img, RGB_map *map, int nbre)
{ {
long surface, maxi; long surface, maxi;
int x, y, r, g, b, idx; int x, y, r, g, b, idx;
@ -81,8 +79,7 @@ struct elem elems[TAILLE];
fprintf(stderr, " Calc map 4 bits: nbre = %d\n", nbre); fprintf(stderr, " Calc map 4 bits: nbre = %d\n", nbre);
#endif #endif
if ( (nbre<1) || (nbre>255) ) if ( (nbre<1) || (nbre>255) ) {
{
fprintf(stderr, "Calc map 4 bits: nbre %d out of range\n", nbre); fprintf(stderr, "Calc map 4 bits: nbre %d out of range\n", nbre);
return BAD_COLOR_NUMBER; return BAD_COLOR_NUMBER;
} }
@ -92,24 +89,20 @@ surface = img->width * img->height;
fprintf(stderr, " calc Map 4 bits: surface de l'image = %ld pixels\n", surface); fprintf(stderr, " calc Map 4 bits: surface de l'image = %ld pixels\n", surface);
#endif #endif
for (x=0; x<TAILLE; x++) for (x=0; x<TAILLE; x++) {
{
elems[x].compte = 0L; elems[x].compte = 0L;
elems[x].rgb = x; elems[x].rgb = x;
} }
maxi = 0L; maxi = 0L;
for (x=0; x<img->width; x++) for (x=0; x<img->width; x++) {
{ for (y=0; y<img->height; y++) {
for (y=0; y<img->height; y++)
{
r = (img->Rpix[y])[x] >> 4; r = (img->Rpix[y])[x] >> 4;
g = (img->Gpix[y])[x] >> 4; g = (img->Gpix[y])[x] >> 4;
b = (img->Bpix[y])[x] >> 4; b = (img->Bpix[y])[x] >> 4;
idx = (r<<8) | (g<<4) | b; idx = (r<<8) | (g<<4) | b;
if (idx >= TAILLE) if (idx >= TAILLE) {
{
fprintf(stderr, "FATAL ERROR in %s\n", __func__); fprintf(stderr, "FATAL ERROR in %s\n", __func__);
exit(5); exit(5);
} }
@ -130,7 +123,6 @@ qsort(elems, TAILLE, sizeof(struct elem), compare_compteur);
/* /*
* trier la palette, certe, mais dans quel ordre ? * trier la palette, certe, mais dans quel ordre ?
*
* 28 Jan 2002: why ? * 28 Jan 2002: why ?
*/ */
qsort(elems, nbre, sizeof(struct elem), compare_teinte); qsort(elems, nbre, sizeof(struct elem), compare_teinte);
@ -138,8 +130,7 @@ qsort(elems, nbre, sizeof(struct elem), compare_teinte);
/* /*
* recopier les 'nbre' entrees hautes dans la palette * recopier les 'nbre' entrees hautes dans la palette
*/ */
for(x=0; x<nbre; x++) for(x=0; x<nbre; x++) {
{
y = elems[x].rgb; y = elems[x].rgb;
r = ((y>>8)&0xf)<<4; r = ((y>>8)&0xf)<<4;

37
Lib/drawalpha.c
View File

@ -19,8 +19,7 @@
/* /*
* the easy one. * the easy one.
*/ */
int int Image_paint_A_rect(Image_Desc *img, Image_Rect *rect, RGBA *rgba)
Image_paint_A_rect(Image_Desc *img, Image_Rect *rect, RGBA *rgba)
{ {
int xd, yd, xf, yf, x, y; int xd, yd, xf, yf, x, y;
int r, g, b, a0, a1, nbre; int r, g, b, a0, a1, nbre;
@ -42,10 +41,8 @@ a1 = rgba->a;
nbre = 0; nbre = 0;
for (x=xd; x<xf; x++) for (x=xd; x<xf; x++) {
{ for (y=yd; y<yf; y++) {
for (y=yd; y<yf; y++)
{
Image_getRGB(img, x, y, &r, &g, &b); Image_getRGB(img, x, y, &r, &g, &b);
/* /*
* ok, compute now... * ok, compute now...
@ -58,18 +55,15 @@ for (x=xd; x<xf; x++)
} }
} }
/* fprintf(stderr, "%d points traités\n", nbre); */
return FUNC_IS_BETA; return FUNC_IS_BETA;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* new 15 Janvier 2003. * new 15 Janvier 2003.
* première utilisation: l'écriture des titres des * premiere utilisation: l'ecriture des titres des
* image de l'expovsition. * image de l'expovsition.
*/ */
int int Image_fade_A_rect(Image_Desc *img, Image_Rect *rect, int alpha)
Image_fade_A_rect(Image_Desc *img, Image_Rect *rect, int alpha)
{ {
int xd, yd, xf, yf, x, y; int xd, yd, xf, yf, x, y;
int r, g, b ; int r, g, b ;
@ -85,10 +79,8 @@ fprintf(stderr, "Fade Alpha Rect: %d < X < %d %d < Y < %d\n",
fprintf(stderr, " coefficient alpha = %d\n", alpha); fprintf(stderr, " coefficient alpha = %d\n", alpha);
#endif #endif
for (x=xd; x<xf; x++) for (x=xd; x<xf; x++) {
{ for (y=yd; y<yf; y++) {
for (y=yd; y<yf; y++)
{
Image_getRGB(img, x, y, &r, &g, &b); Image_getRGB(img, x, y, &r, &g, &b);
/* /*
* ok, compute now... * ok, compute now...
@ -108,34 +100,29 @@ return FUNC_IS_BETA; /* need unit testing */
* bon, une fonction pour tamponner une image quelconque avec une * bon, une fonction pour tamponner une image quelconque avec une
* image alpha, il serait temps de la mettre en place, nom ? * image alpha, il serait temps de la mettre en place, nom ?
*/ */
int int Image_tampon_alpha_0(Image_Desc *src, Image_Desc *tampon, Image_Desc *dst)
Image_tampon_alpha_0(Image_Desc *src, Image_Desc *tampon, Image_Desc *dst)
{ {
int x, y, rs, gs, bs, rt, gt, bt; int x, y, rs, gs, bs, rt, gt, bt;
int rd, gd, bd, clean_tampon; int rd, gd, bd, clean_tampon;
clean_tampon = 0; clean_tampon = 0;
/* if the 'tampon' is not defined, we have to imagine one */ /* if the 'tampon' is not defined, we have to imagine one */
if (NULL==tampon) if (NULL==tampon) {
{
tampon = Image_clone(src, 0); tampon = Image_clone(src, 0);
fprintf(stderr, "fake tampon @ %p\n", tampon); fprintf(stderr, "fake tampon @ %p\n", tampon);
Image_mirror(src, tampon, 0); Image_mirror(src, tampon, 0);
clean_tampon = 1; clean_tampon = 1;
} }
for (y=0; y<src->height; y++) for (y=0; y<src->height; y++) {
{ for (x=0; x<src->width; x++) {
for (x=0; x<src->width; x++)
{
Image_getRGB(src, x, y, &rs, &gs, &bs); Image_getRGB(src, x, y, &rs, &gs, &bs);
Image_getRGB(tampon, x, y, &rt, &gt, &bt); Image_getRGB(tampon, x, y, &rt, &gt, &bt);
rd = (rs * rt) / 256; rd = (rs * rt) / 256;
} }
} }
if (clean_tampon) if (clean_tampon) {
{
fprintf(stderr, "clean %p in %s\n", tampon, __func__); fprintf(stderr, "clean %p in %s\n", tampon, __func__);
Image_DeAllocate(tampon); free(tampon); Image_DeAllocate(tampon); free(tampon);
} }

8
Lib/drawing.c
View File

@ -34,7 +34,7 @@ Image_plotRGB(i, x+xc, y+yc, 100, 100, 100);
fprintf(stderr, "sym %d %d\n", x, y); fprintf(stderr, "sym %d %d\n", x, y);
} }
/* le paramètre 'wrap' ne sert à rien */ /* le parametre 'wrap' ne sert a rien */
int Image_draw_circle(Image_Desc *i, int xc, int yc, int rayon, RGBA *q, int wrap) int Image_draw_circle(Image_Desc *i, int xc, int yc, int rayon, RGBA *q, int wrap)
{ {
int x, y, d; int x, y, d;
@ -111,7 +111,7 @@ return 0;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* XXX si je veux remplacer 'plotRGB' par un accès direct * XXX si je veux remplacer 'plotRGB' par un acces direct
* XXX dans les buffers, il faut soigner les controles * XXX dans les buffers, il faut soigner les controles
*/ */
int Image_paint_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b) int Image_paint_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b)
@ -128,10 +128,10 @@ yd = max(0, rect->y);
xf = min((img->width), (rect->x+rect->w)); xf = min((img->width), (rect->x+rect->w));
yf = min((img->height), (rect->y+rect->h)); yf = min((img->height), (rect->y+rect->h));
/* /*
* 24 Juin 2002: est-ce que le code ci-dessus a été sérieusement validé ? * 24 Juin 2002: est-ce que le code ci-dessus est vraiment valide ?
* 24 Avril 2008: NON ! * 24 Avril 2008: NON !
* 26 janvier 2014 : toujours non... * 26 janvier 2014 : toujours non...
* 19 septembre 2022 : je n'ai pas de certitude à ce sujet * 19 septembre 2022 : je n'ai pas de certitude a ce sujet
*/ */
#if DEBUG_LEVEL > 2 #if DEBUG_LEVEL > 2

55
Lib/effects3.c
View File

@ -1,7 +1,7 @@
/* /*
+---------------------------------------+ +---------------------------------------+
| Effets speciaux sur les images | | Effets speciaux sur les images |
| troisième module | | troisieme module |
+---------------------------------------+ +---------------------------------------+
Thierry Boudet <oulala@chez.com> Thierry Boudet <oulala@chez.com>
*/ */
@ -70,8 +70,7 @@ return FUNC_IS_BETA;
/* /*
* 3 avril 2007: je me rend compte que les parametres ne servent a rien. * 3 avril 2007: je me rend compte que les parametres ne servent a rien.
*/ */
int int Image_effect_x_1(Image_Desc *src, Image_Desc *dst)
Image_effect_x_1(Image_Desc *src, Image_Desc *dst)
{ {
int foo, x, y, r, g, b; int foo, x, y, r, g, b;
@ -86,7 +85,7 @@ for (y=0; y<dst->height; y++) {
g = src->Gpix[y][x]; g = src->Gpix[y][x];
b = src->Bpix[y][x]; b = src->Bpix[y][x];
/* 2 fevrier 2003: je fait du n'importe quoi, là... */ /* 2 fevrier 2003: je fait du n'importe quoi, la... */
dst->Rpix[y][x] = g^b; dst->Rpix[y][x] = g^b;
dst->Gpix[y][x] = r^b; dst->Gpix[y][x] = r^b;
dst->Bpix[y][x] = r^g; dst->Bpix[y][x] = r^g;
@ -97,11 +96,10 @@ return FUNC_IS_BETA;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* 1er Février 2003: encore une autre expérimentation, qui va être * 1er Fevrier 2003: encore une autre experimentation, qui va etre
* basée sur la trigonométrie. * basee sur la trigonometrie.
*/ */
int int Image_effect_x_2(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kv)
Image_effect_x_2(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kv)
{ {
int foo, x, y, r, g, b; int foo, x, y, r, g, b;
double dr, dg, db, ar, ag, ab; double dr, dg, db, ar, ag, ab;
@ -135,7 +133,7 @@ for (y=0; y<dst->height; y++) {
ab = atan2(dr, dg); ab = atan2(dr, dg);
/* /*
* et là, il y a des soucis d'echelle :) * et la il y a des soucis d'echelle :)
* 15 mars 2005: pourquoi 156 ? (XXX) * 15 mars 2005: pourquoi 156 ? (XXX)
*/ */
r = (int)(ar * 156.0); r = (int)(ar * 156.0);
@ -154,14 +152,13 @@ return FUNC_IS_BETA;
/* /*
* 30 Jan 2003: hop, j'improvise pendant que les patates cuisent :) * 30 Jan 2003: hop, j'improvise pendant que les patates cuisent :)
* 4 Fev 2003: et je peaufine pendant que le poulet mijote :) * 4 Fev 2003: et je peaufine pendant que le poulet mijote :)
* 27 Oct 2003: je debugge pendant que le thé infuse :) * 27 Oct 2003: je debugge pendant que le the infuse :)
* 16 Mai 2005: je commence a ecrire la documentation. * 16 Mai 2005: je commence a ecrire la documentation.
* 29 sept 2015: je devrais finir la doc d'ici 2 ans. * 29 sept 2015: je devrais finir la doc d'ici 2 ans.
* 19 aout 2022: je comprend pas ce que c'est censé faire :) * 19 aout 2022: je comprend pas ce que c'est cense faire :)
* *
*/ */
int int Image_effect_x_3(Image_Desc *src, Image_Desc *dst, int kx, int ky, char *comp)
Image_effect_x_3(Image_Desc *src, Image_Desc *dst, int kx, int ky, char *comp)
{ {
int foo, sx, sy; int foo, sx, sy;
int x, y, r, g, b; int x, y, r, g, b;
@ -171,15 +168,13 @@ int cx, cy, dx, dy;
fprintf(stderr, "%s : kx %d ky %d comp '%s'\n", __func__, kx, ky, comp); fprintf(stderr, "%s : kx %d ky %d comp '%s'\n", __func__, kx, ky, comp);
#endif #endif
if ( (foo=Image_compare_desc(src, dst)) ) if ( (foo=Image_compare_desc(src, dst)) ) {
{
fprintf(stderr, "%s: images are differents %d\n", __func__, foo); fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
return foo; return foo;
} }
if (strlen(comp) != 2) if (strlen(comp) != 2) {
{ fprintf(stderr, "%s: bad comp parameter '%s'\n", __func__, comp);
fprintf(stderr, "eff x3: bad comp parameter '%s'\n", comp);
fprintf(stderr, " must be a 2 chars string, from 'rgb'\n"); fprintf(stderr, " must be a 2 chars string, from 'rgb'\n");
return INVALID_PARAM; return INVALID_PARAM;
} }
@ -193,25 +188,22 @@ sx = sy = 0;
/* /*
* ici il faudrait une validation des deux lettres, mais j'ai la * ici il faudrait une validation des deux lettres, mais j'ai la
* flemme d'écrire ça maintenant. je vais plutôt aller boofer. * flemme d'ecrire ce genre de chos maintenant.
* Je vais plutot aller boofer.
*/ */
for (y=0; y<dst->height; y++) for (y=0; y<dst->height; y++) {
{ for (x=0; x<dst->width; x++) {
for (x=0; x<dst->width; x++)
{
r = src->Rpix[y][x]; r = src->Rpix[y][x];
g = src->Gpix[y][x]; g = src->Gpix[y][x];
b = src->Bpix[y][x]; b = src->Bpix[y][x];
switch(cx) switch(cx) {
{
case 'r': dx = r; break; case 'r': dx = r; break;
case 'g': dx = g; break; case 'g': dx = g; break;
case 'b': dx = b; break; case 'b': dx = b; break;
} }
switch(cy) switch(cy) {
{
case 'r': dy = r; break; case 'r': dy = r; break;
case 'g': dy = g; break; case 'g': dy = g; break;
case 'b': dy = b; break; case 'b': dy = b; break;
@ -221,15 +213,13 @@ for (y=0; y<dst->height; y++)
sy = y + ((ky * (dy-128)) / 100); sy = y + ((ky * (dy-128)) / 100);
if ( sx >= 0 && sx < dst->width && if ( sx >= 0 && sx < dst->width &&
sy >= 0 && sy < dst->height ) sy >= 0 && sy < dst->height ) {
{
r = src->Rpix[sy][sx]; r = src->Rpix[sy][sx];
g = src->Gpix[sy][sx]; g = src->Gpix[sy][sx];
b = src->Bpix[sy][sx]; b = src->Bpix[sy][sx];
Image_plotRGB(dst, x, y, r, g, b); Image_plotRGB(dst, x, y, r, g, b);
} }
else else {
{
Image_plotRGB(dst, x, y, r, r, r); Image_plotRGB(dst, x, y, r, r, r);
} }
/* /*
@ -285,8 +275,7 @@ return FUNC_IS_BETA;
* faudrait que les gosses arretent de ma casser les oreilles avec leur * faudrait que les gosses arretent de ma casser les oreilles avec leur
* machine a batailles. putain de gamecube... */ * machine a batailles. putain de gamecube... */
/* 23 aout 2022 : j'ai bien envie d'une SNES et d'un Trinitron */ /* 23 aout 2022 : j'ai bien envie d'une SNES et d'un Trinitron */
int int Image_effect_x_5(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kz)
Image_effect_x_5(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kz)
{ {
int foo, sx, sy; int foo, sx, sy;
int x, y, r, g, b; int x, y, r, g, b;

53
Lib/morpho.c
View File

@ -27,33 +27,24 @@ static struct
* ============================= * =============================
* 23 avril 2007: switched to direct pixel access. * 23 avril 2007: switched to direct pixel access.
*/ */
int int Image_expand_max(Image_Desc *src, Image_Desc *dst, int factor)
Image_expand_max(Image_Desc *src, Image_Desc *dst, int factor)
{ {
int foo, x, y, maxr, maxg, maxb; int foo, x, y, maxr, maxg, maxb;
int r, g, b; int r, g, b;
if ( (foo=Image_compare_desc(src, dst)) ) if ( (foo=Image_compare_desc(src, dst)) ) {
{ fprintf(stderr, "%s: images non compatibles\n", __func__);
return foo; return foo;
} }
if ( 0 != factor ) if ( 0 != factor ) {
{
fprintf(stderr, "%s: factor (%d) must be 0\n", __func__, factor); fprintf(stderr, "%s: factor (%d) must be 0\n", __func__, factor);
} }
#if DEBUG_LEVEL for (y=1; y<src->height-1; y++) {
fprintf(stderr, "expanding MAX %p to %p\n", src, dst); for (x=1; x<src->width-1; x++) {
#endif
for (y=1; y<src->height-1; y++)
{
for (x=1; x<src->width-1; x++)
{
maxr = maxg = maxb = 0; maxr = maxg = maxb = 0;
for (foo=0; foo<9; foo++) for (foo=0; foo<9; foo++) {
{
/* XXX Faster pussy cat ! /* XXX Faster pussy cat !
Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y, Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y,
&r, &g, &b); &r, &g, &b);
@ -78,19 +69,16 @@ dst->modified = 1;
return 0; return 0;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
int int Image_expand_min(Image_Desc *src, Image_Desc *dst, int factor)
Image_expand_min(Image_Desc *src, Image_Desc *dst, int factor)
{ {
int foo, x, y, minr, ming, minb; int foo, x, y, minr, ming, minb;
int r, g, b; int r, g, b;
if ( (foo=Image_compare_desc(src, dst)) ) if ( (foo=Image_compare_desc(src, dst)) ) {
{
return foo; return foo;
} }
if ( 0 != factor ) if ( 0 != factor ) {
{
fprintf(stderr, "%s: factor (%d) must be 0\n", __func__, factor); fprintf(stderr, "%s: factor (%d) must be 0\n", __func__, factor);
} }
@ -98,13 +86,10 @@ if ( 0 != factor )
fprintf(stderr, "expanding MIN %p to %p\n", src, dst); fprintf(stderr, "expanding MIN %p to %p\n", src, dst);
#endif #endif
for (y=1; y<src->height-1; y++) for (y=1; y<src->height-1; y++) {
{ for (x=1; x<src->width-1; x++) {
for (x=1; x<src->width-1; x++)
{
minr = ming = minb = 1664; minr = ming = minb = 1664;
for (foo=0; foo<9; foo++) for (foo=0; foo<9; foo++) {
{
Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y, Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y,
&r, &g, &b); &r, &g, &b);
@ -133,8 +118,7 @@ Image_sortmat_display(FILE *ou, struct sort_pixel *table)
fprintf(ou, "%s ( %p )\n", __func__, table); fprintf(ou, "%s ( %p )\n", __func__, table);
} }
int int Image_Gray_Sorted_Points(Image_Desc *src, Image_Desc *dst, int *filtre)
Image_Gray_Sorted_Points(Image_Desc *src, Image_Desc *dst, int *filtre)
{ {
int x, y, r, g, b; int x, y, r, g, b;
int foo, gris; int foo, gris;
@ -145,13 +129,10 @@ struct sort_pixel pixels[9];
fprintf(stderr, "Image Gray Sorted Points: %p -> %p\n", src, dst); fprintf(stderr, "Image Gray Sorted Points: %p -> %p\n", src, dst);
#endif #endif
for (y=1; y<src->height-1; y++) for (y=1; y<src->height-1; y++) {
{ for (x=1; x<src->width-1; x++) {
for (x=1; x<src->width-1; x++)
{
/* collecte des infos sur les voisins. */ /* collecte des infos sur les voisins. */
for (foo=0; foo<9; foo++) for (foo=0; foo<9; foo++) {
{
Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y, Image_getRGB(src, x+deltas[foo].x, y+deltas[foo].y,
&r, &g, &b); &r, &g, &b);

6
Lib/operat.c
View File

@ -5,8 +5,8 @@
25 Aout 1999: certaines fonctions utilisent 'alloca'. 25 Aout 1999: certaines fonctions utilisent 'alloca'.
4 Fevrier 2001: je me rend compte que certaines interfaces sont trop 4 Fevrier 2001: je me rend compte que certaines interfaces sont trop
simplistes, et que définir des structures contenant de multiples simplistes, et que definir des structures contenant de multiples
paramètres ne serait peut-être pas une mauvaise idée... parametres ne serait peut-etre pas une mauvaise idee...
16 Oct 2001: je deplace quelques fonctions dans d'autres modules. 16 Oct 2001: je deplace quelques fonctions dans d'autres modules.
@ -132,7 +132,7 @@ return FUNC_IS_BETA;
} }
/* /*
* p'taing, c'est tellement crade qu'il faut: * p'taing, c'est tellement crade qu'il faut:
* 1) retrouver d'ou ça vient * 1) retrouver d'ou c,a vient
* 2) la virer illico !... * 2) la virer illico !...
*/ */
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/

110
Lib/plotteur.c
View File

@ -13,7 +13,7 @@
#include "../tthimage.h" #include "../tthimage.h"
#define SOMBRE 26 /* pourquoi ces valeurs sont codées en */ #define SOMBRE 26 /* pourquoi ces valeurs sont codees en */
#define CLAIR 242 /* dur ? et ~/.tth/libimagerc alors ? */ #define CLAIR 242 /* dur ? et ~/.tth/libimagerc alors ? */
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
@ -30,18 +30,16 @@ for (foo=bas; foo<=haut; foo++)
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* new 20 mars 2002 /* new 20 mars 2002
*/ */
int int Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte)
Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte)
{ {
Image_Desc *img; Image_Desc *img;
int foo; int foo;
RGBA paper, ink; RGBA paper, ink;
int vr, vg, vb, ovr, ovg, ovb; int vr, vg, vb, ovr, ovg, ovb;
if ( (img = Image_alloc(400, 300, 3)) == NULL ) if ( (img = Image_alloc(400, 300, 3)) == NULL ) {
{
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "Plot Luts: alloc of img failed, file=%s\n", nomtga); fprintf(stderr, "%s: alloc of img failed, file=%s\n", __func__, nomtga);
#endif #endif
return IMAGE_NO_MEM; return IMAGE_NO_MEM;
} }
@ -138,13 +136,13 @@ fprintf(stderr, "taille txt %d\n", strlen(txt));
Image_trace_chaine_1(img, txt, 5, 5, "libimage.fonte", &paper, &ink); Image_trace_chaine_1(img, txt, 5, 5, "libimage.fonte", &paper, &ink);
#if DEBUG_LEVEL > 1 #if DEBUG_LEVEL > 1
fprintf(stderr, "[%s] tracée...\n", txt); fprintf(stderr, "[%s] drawed...\n", txt);
#endif #endif
sprintf(chaine, "max rgb = %ld", maxhisto); sprintf(chaine, "max rgb = %ld", maxhisto);
Image_trace_chaine_1(img, chaine, 5, 15, NULL, &paper, &ink); Image_trace_chaine_1(img, chaine, 5, 15, NULL, &paper, &ink);
#if DEBUG_LEVEL > 1 #if DEBUG_LEVEL > 1
fprintf(stderr, "[%s] tracée...\n", chaine); fprintf(stderr, "[%s] drawed...\n", chaine);
#endif #endif
Image_cadre_A(img); Image_cadre_A(img);
@ -177,8 +175,7 @@ return FUNC_IS_BETA;
* fabrique dans une image une petite bande a partir d'une palette * fabrique dans une image une petite bande a partir d'une palette
* cette bande est horizontale. * cette bande est horizontale.
*/ */
int int Image_plot_h_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int h)
Image_plot_h_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int h)
{ {
int x, y, v; int x, y, v;
@ -212,15 +209,12 @@ return FUNC_IS_BETA;
* fabrique dans une image une petite bande a partir d'une palette * fabrique dans une image une petite bande a partir d'une palette
* cette bande est verticale. * cette bande est verticale.
*/ */
int int Image_plot_v_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int l)
Image_plot_v_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int l)
{ {
int x, y, v; int x, y, v;
for (y=0; y<256; y++) for (y=0; y<256; y++) {
{ for (x=0; x<l; x++) {
for (x=0; x<l; x++)
{
if ( ((y>>2)+(x>>2)) & 1) v = SOMBRE; if ( ((y>>2)+(x>>2)) & 1) v = SOMBRE;
else v = CLAIR; else v = CLAIR;
Image_plotRGB(img, x+xpos, y+ypos, v, v, v); Image_plotRGB(img, x+xpos, y+ypos, v, v, v);
@ -247,8 +241,7 @@ return FUNC_IS_BETA;
* fabrique une petite TGA horizontale avec une palette dedans * fabrique une petite TGA horizontale avec une palette dedans
*/ */
#define LITTLE_DIM 42 #define LITTLE_DIM 42
int int Image_plot_little_h_Map(char *nom, RGB_map *map, char *texte)
Image_plot_little_h_Map(char *nom, RGB_map *map, char *texte)
{ {
Image_Desc *img; Image_Desc *img;
int foo; int foo;
@ -276,11 +269,10 @@ return FUNC_IS_BETA;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* 20 Février 2002. * 20 Fevrier 2002.
* fabrique une petite TGA verticale avec une palette dedans * fabrique une petite TGA verticale avec une palette dedans
*/ */
int int Image_plot_little_v_Map(char *nom, RGB_map *map, char *texte)
Image_plot_little_v_Map(char *nom, RGB_map *map, char *texte)
{ {
Image_Desc *img; Image_Desc *img;
int foo; int foo;
@ -306,8 +298,7 @@ return FUNC_IS_BETA;
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* new 2 decembre 2009 - ave St Exupery /* new 2 decembre 2009 - ave St Exupery
*/ */
int int Image_plot_square_Map(char *fname, RGB_map *map, char *texte, int k)
Image_plot_square_Map(char *fname, RGB_map *map, char *texte, int k)
{ {
int x, y, foo; int x, y, foo;
int r, g, b; int r, g, b;
@ -320,10 +311,9 @@ fprintf(stderr, "%s ( '%s' %p '%s' %d )\n", __func__,
fname, map, texte, k); fname, map, texte, k);
#endif #endif
if ( (img = Image_alloc(512, 512, 3)) == NULL ) if ( (img = Image_alloc(512, 512, 3)) == NULL ) {
{
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "Plot MAP: alloc of img failed, file=%s\n", fname); fprintf(stderr, "%s: alloc of img failed, file=%s\n", __func__, fname);
#endif #endif
return IMAGE_NO_MEM; return IMAGE_NO_MEM;
} }
@ -332,8 +322,7 @@ Image_clear(img, 0, 0, 0);
rect.h = rect.w = 31; rect.h = rect.w = 31;
for (foo=0; foo<256; foo++) for (foo=0; foo<256; foo++) {
{
x = ( foo & 0x0f ) * 32; x = ( foo & 0x0f ) * 32;
y = ( foo & 0xf0 ) * 2; y = ( foo & 0xf0 ) * 2;
#if DEBUG_LEVEL > 1 #if DEBUG_LEVEL > 1
@ -343,8 +332,7 @@ for (foo=0; foo<256; foo++)
rect.x = x; rect.x = x;
rect.y = y; rect.y = y;
if (foo < map->nbre) if (foo < map->nbre) {
{
r = map->red[foo]; r = map->red[foo];
g = map->green[foo]; g = map->green[foo];
b = map->blue[foo]; b = map->blue[foo];
@ -353,11 +341,7 @@ for (foo=0; foo<256; foo++)
#endif #endif
Image_paint_rect(img, &rect, r, g, b); Image_paint_rect(img, &rect, r, g, b);
} }
else /* on est au dela de la fin de la palette */ else { /* on est au dela de la fin de la palette */
{
#if DEBUG_LEVEL > 1
printf(" xxx\n");
#endif
/* Image_gadrct_Hsweep_0(img, &rect, 0); */ /* Image_gadrct_Hsweep_0(img, &rect, 0); */
Image_gadrct_cross(img, &rect, 0); Image_gadrct_cross(img, &rect, 0);
} }
@ -386,17 +370,14 @@ Image_Rect rect;
if ( (img = Image_alloc(400, 300, 3)) == NULL ) if ( (img = Image_alloc(400, 300, 3)) == NULL )
{ {
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "Plot MAP: alloc of img failed, file=%s\n", nomtga); fprintf(stderr, "%s: alloc of img failed, file=%s\n", __func__, nomtga);
#endif #endif
return IMAGE_NO_MEM; return IMAGE_NO_MEM;
} }
Image_clear(img, SOMBRE, SOMBRE, SOMBRE); Image_clear(img, SOMBRE, SOMBRE, SOMBRE);
for (foo=0; foo<map->nbre; foo++) {
for (foo=0; foo<map->nbre; foo++)
{
Image_plotRGB(img, foo+90, 120, 255, 255, 255); Image_plotRGB(img, foo+90, 120, 255, 255, 255);
Image_plotRGB(img, foo+90, 200, 255, 255, 255); Image_plotRGB(img, foo+90, 200, 255, 255, 255);
Image_plotRGB(img, foo+90, 280, 255, 255, 255); Image_plotRGB(img, foo+90, 280, 255, 255, 255);
@ -414,10 +395,8 @@ Image_draw_rect(img, &rect, CLAIR/2, CLAIR/2, CLAIR/2);
fprintf(stderr, "Plot MAP: the text is '%s'\n", txt); fprintf(stderr, "Plot MAP: the text is '%s'\n", txt);
#endif #endif
for (foo=0; foo<map->nbre; foo++) for (foo=0; foo<map->nbre; foo++) {
{ for (x=21; x<50; x++) {
for (x=21; x<50; x++)
{
Image_plotRGB(img, x, foo+31, Image_plotRGB(img, x, foo+31,
map->red[foo], map->green[foo], map->blue[foo]); map->red[foo], map->green[foo], map->blue[foo]);
} }
@ -427,7 +406,7 @@ paper.r = paper.b = paper.g = SOMBRE; paper.a = 0;
ink.r = ink.b = ink.g = CLAIR; ink.a = 255; ink.r = ink.b = ink.g = CLAIR; ink.a = 255;
foo = Image_trace_chaine_1(img, txt, 15, 7, "8x8thin", &paper, &ink); foo = Image_trace_chaine_1(img, txt, 15, 7, "8x8thin", &paper, &ink);
#if DEBUG_LEVEL > 1 #if DEBUG_LEVEL > 1
fprintf(stderr, "Plot MAP: retour trace chaine = %d\n", foo); fprintf(stderr, "%s: retour trace chaine = %d\n", __func__, foo);
#endif #endif
Image_cadre_A(img); Image_cadre_A(img);
@ -446,8 +425,7 @@ return OLL_KORRECT;
* new 23 oct 2001 * new 23 oct 2001
* parameters 'p1' and 'p2' are not used, and must be 0 ! * parameters 'p1' and 'p2' are not used, and must be 0 !
*/ */
int int Image_plot_histo_hf15(Image_Desc *img, char *nom, char *txt, int p1, int p2)
Image_plot_histo_hf15(Image_Desc *img, char *nom, char *txt, int p1, int p2)
{ {
Image_Desc *plot; Image_Desc *plot;
long *histo, maximum; long *histo, maximum;
@ -460,49 +438,41 @@ char chaine[200];
fprintf(stderr, "%s: img %p ! work in progress !\n", __func__, img); fprintf(stderr, "%s: img %p ! work in progress !\n", __func__, img);
#endif #endif
if ( (histo=alloca(sizeof(long)*32768)) == NULL) if ( (histo=alloca(sizeof(long)*32768)) == NULL) {
{ fprintf(stderr, "%s: no mem for buffer\n", __func__);
fprintf(stderr, "Plot histo hf15: no mem for buffer\n");
#if FORCE_ABORT #if FORCE_ABORT
abort(); abort();
#endif #endif
return BUFFER_NO_MEM; return BUFFER_NO_MEM;
} }
if ( (plot = Image_alloc(800, 600, 3)) == NULL ) if ( (plot = Image_alloc(800, 600, 3)) == NULL ) {
{
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "Plot histo hf15: alloc img failed\n"); fprintf(stderr, "Plot histo hf15: alloc img failed\n");
#endif #endif
free(histo);
return IMAGE_NO_MEM; return IMAGE_NO_MEM;
} }
Image_clear(plot, SOMBRE, SOMBRE, SOMBRE); Image_clear(plot, SOMBRE, SOMBRE, SOMBRE);
for (foo=0; foo<32768; foo++) histo[foo] = 0L; for (foo=0; foo<32768; foo++) histo[foo] = 0L;
#if DEBUG_LEVEL > 1
fprintf(stderr, "Plot histo hf15: buffers allocated, computing now...\n");
#endif
epic_fail = 0; epic_fail = 0;
for (y=0; y<img->height; y++) for (y=0; y<img->height; y++) {
{ for (x=0; x<img->width; x++) {
for (x=0; x<img->width; x++)
{
h = Image_hf15_height(img, x, y); h = Image_hf15_height(img, x, y);
if (h<0 || h>32767) if (h<0 || h>32767) epic_fail++;
epic_fail++; else histo[h]++;
else
histo[h]++;
} }
} }
if (epic_fail) if (epic_fail) {
{ fprintf(stderr, "%s: %d epic fail(s) is epic\n", __func__, epic_fail);
fprintf(stderr, "%s : %d epic fail is epic\n", __func__, epic_fail);
#if FORCE_ABORT #if FORCE_ABORT
abort(); abort();
#endif #endif
free(histo);
} }
/* recherche du maximum de l'histogramme, pour faire la mise a l'echelle */ /* recherche du maximum de l'histogramme, pour faire la mise a l'echelle */
@ -518,12 +488,10 @@ fprintf(stderr, "%s: maximum = %ld, diviseur = %g\n", __func__,
maximum, diviseur); maximum, diviseur);
h2 = 0; h2 = 0;
for (foo=0; foo<32768; foo+=4) for (foo=0; foo<32768; foo+=4) {
{
h = (int)((double)histo[foo] / diviseur); h = (int)((double)histo[foo] / diviseur);
x = (foo/64)+60; x = (foo/64)+60;
if (foo) /* pourquoi ? */ if (foo) { /* pourquoi ? */
{
vline(plot, x, 590-h, 290-h2, 'g', CLAIR); vline(plot, x, 590-h, 290-h2, 'g', CLAIR);
h2 = h; h2 = h;
} }

4
Lib/scale.c
View File

@ -72,6 +72,9 @@ return FUNC_IS_ALPHA;
some approximations\dots some approximations\dots
this function is PRIVATE, see 'Image_getpix_bilin' for public interface this function is PRIVATE, see 'Image_getpix_bilin' for public interface
2022 September : update in progress.
*/ */
static int getpix_bilin(Image_Desc *src, double fx, double fy, static int getpix_bilin(Image_Desc *src, double fx, double fy,
int *pr, int *pg, int *pb) int *pr, int *pg, int *pb)
@ -125,6 +128,7 @@ if (rbb < 0.0) abort();
if (gbb < 0.0) abort(); if (gbb < 0.0) abort();
if (bbb < 0.0) abort(); if (bbb < 0.0) abort();
/* hu ho ? */
rcc = (raa * (1.0-drh)) + (rbb * drh); rcc = (raa * (1.0-drh)) + (rbb * drh);
gcc = (gaa * (1.0-drh)) + (gbb * drh); gcc = (gaa * (1.0-drh)) + (gbb * drh);
bcc = (baa * (1.0-drh)) + (bbb * drh); bcc = (baa * (1.0-drh)) + (bbb * drh);

13
Lib/stereo.c
View File

@ -11,10 +11,9 @@
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* première fonction, assez primitive, mais qui marche. * premiere fonction, assez primitive, mais qui marche.
*/ */
int int Image_combine_stereo_0(Image_Desc *gauche, Image_Desc *droite,
Image_combine_stereo_0(Image_Desc *gauche, Image_Desc *droite,
Image_Desc *stereo) Image_Desc *stereo)
{ {
int x, y, foo; int x, y, foo;
@ -57,8 +56,7 @@ return OLL_KORRECT;
* En fait (30 janv 2008, ave StEx) au lieu de faire du Rouge/Vert * En fait (30 janv 2008, ave StEx) au lieu de faire du Rouge/Vert
* il va faire du Rouge/Bleu. A la demande de Ker2x. * il va faire du Rouge/Bleu. A la demande de Ker2x.
*/ */
int int Image_combine_stereo_1(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
Image_combine_stereo_1(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
int kr, int kg, int kb) int kr, int kg, int kb)
{ {
int x, y, foo, cumul; int x, y, foo, cumul;
@ -99,7 +97,7 @@ return FUNC_IS_BETA;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
* Et pour celui-ci, il faudrait trouver une façon de définir * Et pour celui-ci, il faudrait trouver une maniere de definir
* les composantes pour l'image destination, afin de tenir * les composantes pour l'image destination, afin de tenir
* compte des filtres qui seront dans les lunettes... * compte des filtres qui seront dans les lunettes...
*/ */
@ -112,6 +110,9 @@ int x, y, foo;
int rouge, vert, bleu; int rouge, vert, bleu;
XXX */ XXX */
fprintf(stderr, ">>> %s ( %p %p %p '%c' '%c' )\n", __func__,
s1, s2, d, cr, cl);
fprintf(stderr, "%s: %s missing, sorry.\n", __FILE__, __func__); fprintf(stderr, "%s: %s missing, sorry.\n", __FILE__, __func__);
return FULL_NUCKED; return FULL_NUCKED;

4
Lib/television.c
View File

@ -77,7 +77,7 @@ return FUNC_IS_BETA;
} }
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* new 8 jan 2002 /* new 8 jan 2002
* le paramètre 'yo' ne sert à rien et doit être mis à 0 * le parametre 'yo' ne sert a rien et doit etre mis a 0
*/ */
int Image_TV_gruud(Image_Desc *src, Image_Desc *dst, int yo) int Image_TV_gruud(Image_Desc *src, Image_Desc *dst, int yo)
{ {
@ -123,7 +123,7 @@ return FUNC_IS_BETA;
#define GRIIIZ_SIZE 20 #define GRIIIZ_SIZE 20
/* /*
* le paramètre 'yo' ne sert à rien et doit être mis à 0 * le parametre 'yo' ne sert e rien et doit etre mis a 0
*/ */
int Image_TV_griiiz(Image_Desc *src, Image_Desc *dst, int yo) int Image_TV_griiiz(Image_Desc *src, Image_Desc *dst, int yo)
{ {

2
Lib/tga.c
View File

@ -87,7 +87,7 @@ if (img->magic != MAGIC_OF_IMAGE) {
return NOT_AN_IMAGE_DESC; return NOT_AN_IMAGE_DESC;
} }
/* /*
* mais ça marche pas a tous les coups. il faudrait pouvoir tester si * mais c,a marche pas a tous les coups. il faudrait pouvoir tester si
* le pointeur 'img' est coherent, mais je sais pas comment faire... * le pointeur 'img' est coherent, mais je sais pas comment faire...
*/ */
if (compress != 0) { if (compress != 0) {

11
tthimage.h
View File

@ -4,7 +4,7 @@
http:///la.buvette.org/devel/libimage/ http:///la.buvette.org/devel/libimage/
*/ */
#ifndef IMAGE_VERSION_STRING #ifndef IMAGE_VERSION_STRING
#define IMAGE_VERSION_STRING "0.4.51 pl 32" #define IMAGE_VERSION_STRING "0.4.51 pl 38"
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* /*
@ -1356,8 +1356,17 @@ int Image_Pool_destroy(void *ptr, char *text, int flags);
int Image_quadsym_simple(Image_Desc *src, Image_Desc *dst, int mode); int Image_quadsym_simple(Image_Desc *src, Image_Desc *dst, int mode);
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* from zoom.c */
int Image_essai_zoom(Image_Desc *src, Image_Desc *dst, int Image_essai_zoom(Image_Desc *src, Image_Desc *dst,
double kx, double ky, int flags); double kx, double ky, int flags);
int Image_zoom_000(Image_Desc *src, Image_Desc *dst, Image_Rect *rect,
float kx, float ky);
int Image_zoom_001(Image_Desc *src, Image_Desc *dst, Image_Rect *rect,
float kx, float ky);
int Image_zoom_extract(Image_Desc *src, Image_Desc *dst, Image_Rect *rect,
int flags);
/*::------------------------------------------------------------------::*/ /*::------------------------------------------------------------------::*/
/* imprime.c */ /* imprime.c */