.4.51 pl 28
This commit is contained in:
tTh
parent
20754c17e9
commit
dec52079cd
|
|
@ -1,9 +1,28 @@
|
|||
# libtthimage
|
||||
|
||||
Les fichiers HTML que vous avez ici sont des versions historiques,
|
||||
Les fichiers [HTML](html/) que vous avez ici sont des versions historiques,
|
||||
qui seront peut-être mise à jour au prochain grand refactoring.
|
||||
Leur contenu est donc à prendre avec des pincettes, ymmv.
|
||||
|
||||
Ceci dit, les principes généraux sont encore bons...
|
||||
Ceci dit, les principes généraux sont encore bons. Mais il y a quelques
|
||||
points à préciser.
|
||||
|
||||
## Compilation
|
||||
|
||||
Certaines options de compilation sont dans le fichier de
|
||||
[paramètres](../Paramakes.mk) pour les différents fichiers make.
|
||||
|
||||
Le script [build.sh](../build.sh) tente d'automatiser les
|
||||
compilations de la bibilothèque, des tests et des outils
|
||||
en ligne de commande.
|
||||
|
||||
## Installation
|
||||
|
||||
Le script [install.sh](../install.sh) va installer divers fichiers
|
||||
aux bonnes places là où on lui dit avec la variable `DESTDIR`.
|
||||
Attention, celle-ci doit être cohérente avec les valeurs déclarée
|
||||
dans le fichier Paramakes.mk !
|
||||
|
||||
## Utilisation
|
||||
|
||||
???
|
||||
|
|
|
|||
|
|
@ -124,6 +124,7 @@ text1.o: text1.c $(DEPS)
|
|||
text16x24.o: text16x24.c $(DEPS)
|
||||
tga.o: tga.c $(DEPS)
|
||||
tools.o: tools.c $(DEPS)
|
||||
trigo.o: trigo.c $(DEPS)
|
||||
turtle.o: turtle.c $(DEPS)
|
||||
|
||||
vignetize.o: vignetize.c $(DEPS)
|
||||
|
|
@ -172,7 +173,7 @@ OBJECTS = 7seg.o \
|
|||
scale.o sobel4.o stereo.o \
|
||||
tamppool.o tele_2.o television.o \
|
||||
text0.o text1.o text16x24.o \
|
||||
tga.o tools.o turtle.o \
|
||||
tga.o tools.o trigo.o turtle.o \
|
||||
vignetize.o \
|
||||
warp0.o warp1.o warp2.o warp3.o \
|
||||
zoom.o
|
||||
|
|
|
|||
|
|
@ -23,8 +23,7 @@
|
|||
/*
|
||||
* le paramètre 'zak' n'est pas utilisé et doit être mis à 0
|
||||
*/
|
||||
int
|
||||
Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int sy, int oy, int zak)
|
||||
{
|
||||
int foo, x, y, my, r, g, b;
|
||||
|
|
@ -67,8 +66,7 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* le paramètre 'zak' n'est pas utilisé et doit être mis à 0
|
||||
*/
|
||||
int
|
||||
Image_combine_columns(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int Image_combine_columns(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int sx, int ox, int zak)
|
||||
{
|
||||
int foo, x, y, mx, r, g, b;
|
||||
|
|
@ -116,8 +114,7 @@ return OLL_KORRECT;
|
|||
*
|
||||
* 'zak' parameter is not used, and must be 0.
|
||||
*/
|
||||
int
|
||||
Image_combine_checker(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int Image_combine_checker(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int sx, int sy, int ox, int oy, int zak)
|
||||
{
|
||||
int foo, r, g, b;
|
||||
|
|
@ -176,8 +173,7 @@ return 0;
|
|||
*
|
||||
* Tiens, le parametre 'yo' ne sert a rien ?
|
||||
*/
|
||||
int
|
||||
Image_combine_cercle_flou(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int yo)
|
||||
int Image_combine_cercle_flou(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int yo)
|
||||
{
|
||||
int foo;
|
||||
int xcenter, ycenter;
|
||||
|
|
@ -243,8 +239,7 @@ return OLL_KORRECT;
|
|||
* le flag 'yo' decide quelle image sera en haut à droite.
|
||||
* les paramètres p1 & p2 ne sont pas utilisés.
|
||||
*/
|
||||
int
|
||||
Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
|
||||
int yo, int p1, int p2)
|
||||
{
|
||||
int foo;
|
||||
|
|
@ -305,8 +300,7 @@ return OLL_KORRECT;
|
|||
we put in the destination image the min/max value
|
||||
of the RGB componants.
|
||||
*/
|
||||
int
|
||||
Image_combine_minmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int flg)
|
||||
int Image_combine_minmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d, int flg)
|
||||
{
|
||||
int foo, x, y, r, g, b;
|
||||
int r1, r2, g1, g2, b1, b2;
|
||||
|
|
@ -352,8 +346,7 @@ return OLL_KORRECT;
|
|||
* 6 oct 2001: une version qui permettrait de spécifier les
|
||||
* seuils en r,g et b serait assez pratique aussi.
|
||||
*/
|
||||
int
|
||||
Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d)
|
||||
int Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d)
|
||||
{
|
||||
int foo, x, y, r, g, b;
|
||||
|
||||
|
|
@ -389,10 +382,9 @@ return FUNC_IS_BETA; /* XXX c'est pas du OLL_KORRECT ? */
|
|||
/*
|
||||
* gni ?
|
||||
*/
|
||||
int
|
||||
Image_poke_2zones(Image_Desc *src, Image_Desc *ia, Image_Desc *ib,
|
||||
int Image_poke_2zones(Image_Desc *src, Image_Desc *ia, Image_Desc *ib,
|
||||
Image_Rect *za, Image_Rect *zb,
|
||||
Image_Desc *dst)
|
||||
Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
/* Image_Rect rect; */
|
||||
|
|
|
|||
102
Lib/effects.c
102
Lib/effects.c
|
|
@ -32,20 +32,17 @@ int x, y, nx, ny, r, g, b, foo;
|
|||
int retry;
|
||||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(source, but)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(source, but)) ) {
|
||||
fprintf(stderr, "%s : images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (intensite < 1)
|
||||
{
|
||||
if (intensite < 1) {
|
||||
fprintf(stderr, "%s : bad intensity %d\n", __func__, intensite);
|
||||
intensite = 1;
|
||||
}
|
||||
|
||||
if (source == but)
|
||||
{
|
||||
if (source == but) {
|
||||
fprintf(stderr, "%s : Source & Target are the same image, bad effect expected...\n", __func__ );
|
||||
}
|
||||
|
||||
|
|
@ -53,13 +50,10 @@ if (source == but)
|
|||
retry = 0;
|
||||
#endif
|
||||
|
||||
for (x=0; x<source->width; x++)
|
||||
{
|
||||
for (y=0; y<source->height; y++)
|
||||
{
|
||||
for (x=0; x<source->width; x++) {
|
||||
for (y=0; y<source->height; y++) {
|
||||
foo = -1;
|
||||
do
|
||||
{
|
||||
do {
|
||||
nx = x+(rand()%intensite)-(intensite/2);
|
||||
ny = y+(rand()%intensite)-(intensite/2);
|
||||
foo++;
|
||||
|
|
@ -135,54 +129,46 @@ return OLL_KORRECT;
|
|||
j'ai rapidement besoin de cette fonction alors je code
|
||||
a la rache :-[ (on appelle aussi c,a le codage 123momo)
|
||||
*/
|
||||
int
|
||||
Image_mirror(Image_Desc *src, Image_Desc *dst, int reserved)
|
||||
int Image_mirror(Image_Desc *src, Image_Desc *dst, int reserved)
|
||||
{
|
||||
register int x;
|
||||
uint8_t *buffer;
|
||||
int foo, largeur, y;
|
||||
|
||||
if (reserved != 0)
|
||||
fprintf(stderr, "Image_Mirror: reserved must be zero !\n");
|
||||
fprintf(stderr, "%s: reserved must be zero !\n", __func__);
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_Mirror: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
largeur = src->width;
|
||||
|
||||
if ((buffer = (uint8_t *)malloc(largeur)) == NULL)
|
||||
{
|
||||
fprintf(stderr, "Image_Mirror: no memory for buffer");
|
||||
if ((buffer = (uint8_t *)malloc(largeur)) == NULL) {
|
||||
fprintf(stderr, "%s: no memory for buffer\n", __func__);
|
||||
return BUFFER_NO_MEM;
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
if (src->Rpix != NULL)
|
||||
{
|
||||
for (y=0; y<src->height; y++) {
|
||||
if (src->Rpix != NULL) {
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Rpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Rpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Gpix != NULL)
|
||||
{
|
||||
if (src->Gpix != NULL) {
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Gpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Gpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Bpix != NULL)
|
||||
{
|
||||
if (src->Bpix != NULL) {
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Bpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Bpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Apix != NULL)
|
||||
{
|
||||
if (src->Apix != NULL) {
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Apix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
|
|
@ -202,19 +188,16 @@ Image_upside_down(Image_Desc *src, Image_Desc *dst, int reserved)
|
|||
{
|
||||
int foo, y;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_UpsideDown: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (0 != reserved)
|
||||
{
|
||||
if (0 != reserved) {
|
||||
fprintf(stderr, "%s gni ?\n", __func__);
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
for (y=0; y<src->height; y++) {
|
||||
memcpy(dst->Rpix[y], src->Rpix[src->height-(y+1)], src->width);
|
||||
memcpy(dst->Gpix[y], src->Gpix[src->height-(y+1)], src->width);
|
||||
memcpy(dst->Bpix[y], src->Bpix[src->height-(y+1)], src->width);
|
||||
|
|
@ -240,8 +223,7 @@ fprintf(stderr, "Scratching %ld times %p to %p\n", nombre, source, but);
|
|||
|
||||
Image_copy(source, but);
|
||||
|
||||
while (nombre--)
|
||||
{
|
||||
while (nombre--) {
|
||||
xs = rand() % source->width;
|
||||
ys = rand() % source->height;
|
||||
xd = rand() % source->width;
|
||||
|
|
@ -261,21 +243,18 @@ Image_swap_lines( Image_Desc *src, Image_Desc * dst )
|
|||
{
|
||||
int foo, line;
|
||||
|
||||
if (src == dst)
|
||||
{
|
||||
fprintf(stderr, "Image swap lines: SRC & DST must be different\n");
|
||||
if (src == dst) {
|
||||
fprintf(stderr, "%s: SRC & DST must be different\n", __func__);
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image swap lines: images have differents sizes. %d\n",
|
||||
foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images have differents sizes. %d\n",
|
||||
__func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (line=0; line<(src->height-1); line+=2)
|
||||
{
|
||||
for (line=0; line<(src->height-1); line+=2) {
|
||||
memcpy(dst->Rpix[line+1], src->Rpix[line], src->width);
|
||||
memcpy(dst->Rpix[line], src->Rpix[line+1], src->width);
|
||||
memcpy(dst->Gpix[line+1], src->Gpix[line], src->width);
|
||||
|
|
@ -294,15 +273,13 @@ Image_swap_cols( Image_Desc *src, Image_Desc * dst )
|
|||
{
|
||||
int foo, line, col, tmp, wmax;
|
||||
|
||||
if (src == dst)
|
||||
{
|
||||
fprintf(stderr, "Image_SwapCols: SRC & DST must be different\n");
|
||||
if (src == dst) {
|
||||
fprintf(stderr, "%s: SRC & DST must be different\n", __func__);
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_SwapCols: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -312,10 +289,8 @@ else
|
|||
wmax = src->width;
|
||||
fprintf(stderr, "swap cols %d %d\n", src->width, wmax);
|
||||
|
||||
for (line=0; line<src->height; line++)
|
||||
{
|
||||
for (col=0; col<wmax; col+=2)
|
||||
{
|
||||
for (line=0; line<src->height; line++) {
|
||||
for (col=0; col<wmax; col+=2) {
|
||||
tmp = src->Rpix[line][col];
|
||||
dst->Rpix[line][col] = src->Rpix[line][col+1];
|
||||
dst->Rpix[line][col+1] = tmp;
|
||||
|
|
@ -343,16 +318,13 @@ Image_swap_nibbles( Image_Desc *src, Image_Desc * dst )
|
|||
int foo;
|
||||
int x, y;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (x=0; x<src->width; x++)
|
||||
{
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
for (x=0; x<src->width; x++) {
|
||||
for (y=0; y<src->height; y++) {
|
||||
dst->Rpix[y][x] = ((src->Rpix[y][x] & 0xf0) >> 4) |
|
||||
((src->Rpix[y][x] & 0x0f) << 4);
|
||||
|
||||
|
|
|
|||
|
|
@ -19,8 +19,7 @@
|
|||
* la parametre 'table' est un tableau de 6 double. d'accord,
|
||||
* mais quel est donc son contenu ?
|
||||
*/
|
||||
int
|
||||
Image_sinwave_0( Image_Desc *source, Image_Desc * but, double *table )
|
||||
int Image_sinwave_0( Image_Desc *source, Image_Desc * but, double *table )
|
||||
{
|
||||
#if DEBUG_LEVEL > 1
|
||||
int foo;
|
||||
|
|
@ -41,18 +40,15 @@ for (foo=0; foo<6; foo++)
|
|||
cx = (2.0 * M_PI) / (double)source->width;
|
||||
cy = (2.0 * M_PI) / (double)source->height;
|
||||
|
||||
for (x=0; x<source->width; x++)
|
||||
{
|
||||
for (x=0; x<source->width; x++) {
|
||||
fx = (double)x + (table[1] * sin(table[4] + (cx * table[0] * (double)x)));
|
||||
xb = floor(fx + 0.5);
|
||||
|
||||
for (y=0; y<source->height; y++)
|
||||
{
|
||||
for (y=0; y<source->height; y++) {
|
||||
fy = (double)y + (table[3] * sin(table[5] + cy * table[2] * (double)y));
|
||||
yb = floor(fy + 0.5);
|
||||
|
||||
if ( xb>0 && yb>0 && xb<but->width && yb<but->height )
|
||||
{
|
||||
if ( xb>0 && yb>0 && xb<but->width && yb<but->height ) {
|
||||
r = (source->Rpix[yb])[xb];
|
||||
g = (source->Gpix[yb])[xb];
|
||||
b = (source->Bpix[yb])[xb];
|
||||
|
|
@ -61,11 +57,7 @@ for (x=0; x<source->width; x++)
|
|||
(but->Gpix[y])[x] = g;
|
||||
(but->Bpix[y])[x] = b;
|
||||
}
|
||||
else
|
||||
{
|
||||
outside++;
|
||||
/* ??? foo = Image_plotRGB(but, x, y, 0, 0, 0); */
|
||||
}
|
||||
else { outside++; }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -85,8 +77,7 @@ return OLL_KORRECT;
|
|||
* Les parametres sont en deux groupes de 3 dans la table.
|
||||
* mais franchement, j'arrive plus a savoir a quoi ils servent.
|
||||
*/
|
||||
int
|
||||
Image_sinwave_1( Image_Desc *source, Image_Desc * but, double *table )
|
||||
int Image_sinwave_1( Image_Desc *source, Image_Desc * but, double *table )
|
||||
{
|
||||
int foo, x, y, xb, yb, r, g, b;
|
||||
long outside = 0;
|
||||
|
|
@ -197,7 +188,7 @@ fprintf(stderr, ">> %s ( %p %p %d %d )\n", __func__, source, but, k1, k2);
|
|||
fprintf(stderr, "Degouline %d %d\n", k1, k2);
|
||||
|
||||
if ( (foo=Image_compare_desc(source, but)) ) {
|
||||
fprintf(stderr, "Image Degouline 2: images are differents %d\n", foo);
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,8 +20,7 @@
|
|||
* 11 Fev 2003: que vais-je mettre ici ?
|
||||
* 5 avr 2007: je commence a en avoir une idee plus precise.
|
||||
*/
|
||||
int
|
||||
Image_effect_x_0(Image_Desc *src, Image_Desc *dst, int kr, int kg, int kb)
|
||||
int Image_effect_x_0(Image_Desc *src, Image_Desc *dst, int kr, int kg, int kb)
|
||||
{
|
||||
int foo, x, y, r, g, b;
|
||||
int cr, cg, cb;
|
||||
|
|
@ -30,9 +29,8 @@ int cr, cg, cb;
|
|||
fprintf(stderr, "*** Effect X_0: coeffs: %d %d %d\n", kr, kg, kb);
|
||||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image effect x 0: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -40,7 +38,10 @@ cr = cg = cb = 0; /* raz des compteurs */
|
|||
|
||||
for (y=0; y<dst->height; y++) {
|
||||
for (x=0; x<dst->width; x++) {
|
||||
Image_getRGB(src, x, y, &r, &g, &b);
|
||||
/* Image_getRGB(src, x, y, &r, &g, &b); */
|
||||
r = src->Rpix[y][x];
|
||||
g = src->Gpix[y][x];
|
||||
b = src->Bpix[y][x];
|
||||
if (r > kr) {
|
||||
foo = g; g = b; b = foo;
|
||||
cr ++;
|
||||
|
|
@ -53,11 +54,14 @@ for (y=0; y<dst->height; y++) {
|
|||
foo = g; g = r; r = foo;
|
||||
cb ++;
|
||||
}
|
||||
Image_plotRGB(dst, x, y, r, g, b);
|
||||
/* Image_plotRGB(dst, x, y, r, g, b); */
|
||||
dst->Rpix[y][x] = r;
|
||||
dst->Gpix[y][x] = g;
|
||||
dst->Bpix[y][x] = b;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "* %s : counts: %d %d %d\n", __func__, cr, cg, cb);
|
||||
/* fprintf(stderr, "* %s : counts: %d %d %d\n", __func__, cr, cg, cb); */
|
||||
|
||||
return FUNC_IS_BETA;
|
||||
}
|
||||
|
|
@ -71,16 +75,13 @@ Image_effect_x_1(Image_Desc *src, Image_Desc *dst)
|
|||
{
|
||||
int foo, x, y, r, g, b;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image effect x 1: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "I%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=0; y<dst->height; y++)
|
||||
{
|
||||
for (x=0; x<dst->width; x++)
|
||||
{
|
||||
for (y=0; y<dst->height; y++) {
|
||||
for (x=0; x<dst->width; x++) {
|
||||
r = src->Rpix[y][x];
|
||||
g = src->Gpix[y][x];
|
||||
b = src->Bpix[y][x];
|
||||
|
|
@ -105,9 +106,8 @@ Image_effect_x_2(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kv)
|
|||
int foo, x, y, r, g, b;
|
||||
double dr, dg, db, ar, ag, ab;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image effect x 2: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -252,7 +252,7 @@ fprintf(stderr, "*** effect x4 is not ready for prime time ***\n");
|
|||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "Image effect x 4: images are differents %d\n", foo);
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -299,16 +299,13 @@ fprintf(stderr, ">>> %s ( %p %p %d %d %d )\n", __func__, src, dst,
|
|||
kx, ky, kz);
|
||||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "Image effect x 5: images are differents %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
for (x=0; x<src->width; x++)
|
||||
{
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
r = src->Rpix[y][x];
|
||||
g = src->Gpix[y][x];
|
||||
b = src->Bpix[y][x];
|
||||
|
|
@ -322,8 +319,7 @@ for (y=0; y<src->height; y++)
|
|||
g2 = (int)(dg2 * 255.0);
|
||||
b2 = (int)(db2 * 255.0);
|
||||
#if DEBUG_LEVEL
|
||||
if (x==42 && y==42)
|
||||
{
|
||||
if (x==42 && y==42) {
|
||||
printf("{{{ pixels %3d %3d %3d }}}\n", r, g, b);
|
||||
printf("{{{ result %3d %3d %3d }}}\n", r2, g2, b2);
|
||||
}
|
||||
|
|
|
|||
131
Lib/filtres.c
131
Lib/filtres.c
|
|
@ -28,8 +28,7 @@ fprintf(ou, "\t+--------------------+------------------+\n");
|
|||
fflush(ou);
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
void
|
||||
Image_rotate_filtre(int *m)
|
||||
void Image_rotate_filtre(int *m)
|
||||
{
|
||||
register int foo;
|
||||
|
||||
|
|
@ -44,8 +43,7 @@ m[2] = m[1];
|
|||
m[1] = foo;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
int
|
||||
Image_convolueur3(Image_Desc *in, Image_Desc *out, int *mat)
|
||||
int Image_convolueur3(Image_Desc *in, Image_Desc *out, int *mat)
|
||||
{
|
||||
int foo;
|
||||
|
||||
|
|
@ -57,22 +55,19 @@ foo = Image_convolueur_2(in, out, mat, "rgb");
|
|||
return foo;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
int
|
||||
Image_convolueur_2(Image_Desc *in, Image_Desc *out, int *mat, char *planes)
|
||||
int Image_convolueur_2(Image_Desc *in, Image_Desc *out, int *mat, char *planes)
|
||||
{
|
||||
int foo, x, y;
|
||||
long lval;
|
||||
int masque = 0;
|
||||
|
||||
if (in == out)
|
||||
{
|
||||
fprintf(stderr, "convolueur 2: out overwrite in.\n");
|
||||
if (in == out) {
|
||||
fprintf(stderr, "%s: out overwrite in.\n", __func__);
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(in, out)) )
|
||||
{
|
||||
fprintf(stderr, "Convolueur: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(in, out)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -85,9 +80,8 @@ Image_dump_descriptor(out, "image de sortie convolueur");
|
|||
Image_filtre_display(stdout, mat);
|
||||
#endif
|
||||
|
||||
if (mat[9] == 0)
|
||||
{
|
||||
fprintf(stderr, "Convolueur: fuck, divisor is ZERO !\n");
|
||||
if (mat[9] == 0) {
|
||||
fprintf(stderr, "%s: fsck, divisor is ZERO !\n", __func__);
|
||||
/*
|
||||
! c'est sur, avec un message comme c,a je vais pas
|
||||
! pouvoir transmettre mon code aux australiens
|
||||
|
|
@ -99,10 +93,8 @@ if (mat[9] == 0)
|
|||
/*
|
||||
* preparation of the binary mask from the parameter string
|
||||
*/
|
||||
for (foo=0; foo<(int)strlen(planes); foo++)
|
||||
{
|
||||
switch (planes[foo])
|
||||
{
|
||||
for (foo=0; foo<(int)strlen(planes); foo++) {
|
||||
switch (planes[foo]) {
|
||||
case 'r': case 'R':
|
||||
masque |= 8;
|
||||
break;
|
||||
|
|
@ -122,18 +114,14 @@ for (foo=0; foo<(int)strlen(planes); foo++)
|
|||
printf("masque convolueur = %02x\n", masque);
|
||||
#endif
|
||||
|
||||
if ( (masque & 1) && (in->Apix == NULL) )
|
||||
{
|
||||
fprintf(stderr, "Convolueur2: filtering NULL alpha plane is _bad_\n");
|
||||
if ( (masque & 1) && (in->Apix == NULL) ) {
|
||||
fprintf(stderr, "%s: filtering NULL alpha plane is _bad_\n", __func__);
|
||||
return WRONG_CHANNEL;
|
||||
}
|
||||
|
||||
for (y=1; y<((in->height)-1); y++)
|
||||
{
|
||||
for (x=1; x<((in->width)-1); x++)
|
||||
{
|
||||
if (masque & 8)
|
||||
{
|
||||
for (y=1; y<((in->height)-1); y++) {
|
||||
for (x=1; x<((in->width)-1); x++) {
|
||||
if (masque & 8) {
|
||||
lval = mat[0] * in->Rpix[y-1][x-1] +
|
||||
mat[1] * in->Rpix[y-1][x] +
|
||||
mat[2] * in->Rpix[y-1][x+1] +
|
||||
|
|
@ -150,8 +138,7 @@ for (y=1; y<((in->height)-1); y++)
|
|||
out->Rpix[y][x] = (uint8_t)lval;
|
||||
}
|
||||
|
||||
if (masque & 4)
|
||||
{
|
||||
if (masque & 4) {
|
||||
lval = mat[0] * in->Gpix[y-1][x-1] +
|
||||
mat[1] * in->Gpix[y-1][x] +
|
||||
mat[2] * in->Gpix[y-1][x+1] +
|
||||
|
|
@ -168,8 +155,7 @@ for (y=1; y<((in->height)-1); y++)
|
|||
out->Gpix[y][x] = (uint8_t)lval;
|
||||
}
|
||||
|
||||
if (masque & 2)
|
||||
{
|
||||
if (masque & 2) {
|
||||
lval = mat[0] * in->Bpix[y-1][x-1] +
|
||||
mat[1] * in->Bpix[y-1][x] +
|
||||
mat[2] * in->Bpix[y-1][x+1] +
|
||||
|
|
@ -186,8 +172,7 @@ for (y=1; y<((in->height)-1); y++)
|
|||
out->Bpix[y][x] = (uint8_t)lval;
|
||||
}
|
||||
|
||||
if (masque & 1)
|
||||
{
|
||||
if (masque & 1) {
|
||||
lval = mat[0] * in->Apix[y-1][x-1] +
|
||||
mat[1] * in->Apix[y-1][x] +
|
||||
mat[2] * in->Apix[y-1][x+1] +
|
||||
|
|
@ -211,13 +196,11 @@ out->modified = 1;
|
|||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
int
|
||||
Image_raz_sides(Image_Desc *im)
|
||||
int Image_raz_sides(Image_Desc *im)
|
||||
{
|
||||
int foo;
|
||||
|
||||
for (foo=0; foo<im->width; foo++)
|
||||
{
|
||||
for (foo=0; foo<im->width; foo++) {
|
||||
(im->Rpix[0])[foo] = 0;
|
||||
(im->Gpix[0])[foo] = 0;
|
||||
(im->Bpix[0])[foo] = 0;
|
||||
|
|
@ -226,8 +209,7 @@ for (foo=0; foo<im->width; foo++)
|
|||
(im->Bpix[im->height-1])[foo] = 0;
|
||||
}
|
||||
|
||||
for (foo=0; foo<im->height; foo++)
|
||||
{
|
||||
for (foo=0; foo<im->height; foo++) {
|
||||
(im->Rpix[foo])[0] = 0;
|
||||
(im->Gpix[foo])[0] = 0;
|
||||
(im->Bpix[foo])[0] = 0;
|
||||
|
|
@ -243,27 +225,22 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* Arf, le grand classique :)
|
||||
*/
|
||||
int
|
||||
Image_lissage_3x3(Image_Desc *in, Image_Desc *out)
|
||||
int Image_lissage_3x3(Image_Desc *in, Image_Desc *out)
|
||||
{
|
||||
int foo, x, y;
|
||||
|
||||
if (in == out)
|
||||
{
|
||||
fprintf(stderr, "Lissage 3x3: out overwrite in\n");
|
||||
if (in == out) {
|
||||
fprintf(stderr, "%s: out overwrite in\n", __func__);
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(in, out)) )
|
||||
{
|
||||
fprintf(stderr, "Lissage 3x3: images have differents size, %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(in, out)) ) {
|
||||
fprintf(stderr, "%s: images have differents size, %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=1; y<((in->height)-1); y++)
|
||||
{
|
||||
for (x=1; x<((in->width)-1); x++)
|
||||
{
|
||||
for (y=1; y<((in->height)-1); y++) {
|
||||
for (x=1; x<((in->width)-1); x++) {
|
||||
|
||||
foo = in->Rpix[y-1][x-1] + in->Rpix[y-1][x] + in->Rpix[y-1][x+1] +
|
||||
in->Rpix[y] [x-1] + in->Rpix[y] [x] + in->Rpix[y] [x+1] +
|
||||
|
|
@ -292,11 +269,9 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* new 14 Jan 2000
|
||||
*/
|
||||
int
|
||||
Image_filtre_Prewitt(Image_Desc *src, Image_Desc *dst, int rotation)
|
||||
int Image_filtre_Prewitt(Image_Desc *src, Image_Desc *dst, int rotation)
|
||||
{
|
||||
static int Prewitt[] =
|
||||
{
|
||||
static int Prewitt[] = {
|
||||
1, 1, 1,
|
||||
0, 0, 0,
|
||||
-1, -1, -1,
|
||||
|
|
@ -318,11 +293,9 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* XXX cette fonction est incorrecte XXX
|
||||
*/
|
||||
int
|
||||
Image_filtre_Sobel(Image_Desc *src, Image_Desc *dst, int rotation)
|
||||
int Image_filtre_Sobel(Image_Desc *src, Image_Desc *dst, int rotation)
|
||||
{
|
||||
static int Sobel[] =
|
||||
{
|
||||
static int Sobel[] = {
|
||||
1, 2, 1,
|
||||
0, 0, 0,
|
||||
-1, -2, -1,
|
||||
|
|
@ -343,13 +316,11 @@ return OLL_KORRECT;
|
|||
* Voir aussi 'sobel4.c' */
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* new 15 Jan 2000 */
|
||||
int
|
||||
Image_filtre_passe_bas(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_filtre_passe_bas(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
|
||||
static int PasseBas[] =
|
||||
{
|
||||
static int PasseBas[] = {
|
||||
1, 2, 1,
|
||||
2, 4, 2,
|
||||
1, 2, 1,
|
||||
|
|
@ -363,14 +334,12 @@ return foo;
|
|||
/*::------------------------------------------------------------------::*/
|
||||
/* nouveau: 18 Janvier 2001
|
||||
moral à zéro, il faut que je fasse pédaler le 486 ! */
|
||||
int
|
||||
Image_filtre_random(Image_Desc *src, Image_Desc *dst, int p1, int p2)
|
||||
int Image_filtre_random(Image_Desc *src, Image_Desc *dst, int p1, int p2)
|
||||
{
|
||||
int filtre[11];
|
||||
int foo, somme, v, delta;
|
||||
|
||||
if (p1 == p2)
|
||||
{
|
||||
if (p1 == p2) {
|
||||
fprintf(stderr, "%s: p1=%d must be different from p2=%d\n",
|
||||
__func__, p1, p2);
|
||||
return INVALID_PARAM;
|
||||
|
|
@ -383,8 +352,7 @@ delta = abs(p2 - p1);
|
|||
fprintf(stderr, "%s: delta is %d\n", __func__, delta);
|
||||
#endif
|
||||
|
||||
for (foo=0; foo<9; foo++)
|
||||
{
|
||||
for (foo=0; foo<9; foo++) {
|
||||
v = (rand()%delta)+p1;
|
||||
filtre[foo] = v;
|
||||
somme += v;
|
||||
|
|
@ -405,15 +373,14 @@ return FUNC_IS_BETA;
|
|||
/* nouveau: 3 Fevrier 2001
|
||||
on s'inspire de la precedente.
|
||||
*/
|
||||
int
|
||||
Image_filtre_random_2(Image_Desc *src, Image_Desc *dst,
|
||||
int Image_filtre_random_2(Image_Desc *src, Image_Desc *dst,
|
||||
int p1, int p2, int p3, int p4)
|
||||
{
|
||||
int filtre[11];
|
||||
int foo, somme, v, delta, deltb;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "Filtre Random 2: %d %d / %d %d\n", p1, p2, p3, p4);
|
||||
fprintf(stderr, "%s: %d %d / %d %d\n", __func__, p1, p2, p3, p4);
|
||||
#endif
|
||||
|
||||
delta = abs(p2 - p1);
|
||||
|
|
@ -423,22 +390,18 @@ fprintf(stderr, "Filtre Random 2: delta are %d %d\n", delta, deltb);
|
|||
#endif
|
||||
|
||||
somme = 0;
|
||||
for (foo=0; foo<9; foo++)
|
||||
{
|
||||
if (foo != 4)
|
||||
{
|
||||
for (foo=0; foo<9; foo++) {
|
||||
if (foo != 4) {
|
||||
v = (rand()%delta)+p1;
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
v = (rand()%deltb)+p3;
|
||||
}
|
||||
filtre[foo] = v;
|
||||
|
||||
somme += v;
|
||||
}
|
||||
|
||||
filtre[9] = somme;
|
||||
filtre[9] = somme;
|
||||
filtre[10] = 0; /* XXX calcul automatique a faire ! */
|
||||
|
||||
Image_filtre_display(stdout, filtre);
|
||||
|
|
@ -448,12 +411,10 @@ foo = Image_convolueur_2(src, dst, filtre, "rgb");
|
|||
return FUNC_IS_BETA;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
int
|
||||
Image_filtre_passe_haut(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_filtre_passe_haut(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
static int PasseHaut[] =
|
||||
{
|
||||
static int PasseHaut[] = {
|
||||
-1, -1, -1,
|
||||
-1, 8, -1,
|
||||
-1, -1, -1,
|
||||
|
|
|
|||
|
|
@ -124,6 +124,9 @@ for (nbre=0; nbre<k; nbre++)
|
|||
for (v=y; v<src->height; v++)
|
||||
Image_plotRGB(dst, x, v, r, g, b);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "blurg in %s\n", __func__);
|
||||
return PASTIS;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
17
Lib/image.c
17
Lib/image.c
|
|
@ -487,19 +487,16 @@ return (int)((img->Apix[y])[x]);
|
|||
cette fonction ne marche que si les deux images
|
||||
sont allouees et de meme dimensions.
|
||||
*/
|
||||
int
|
||||
Image_copy(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_copy(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_Copy: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (foo=0; foo<src->height; foo++)
|
||||
{
|
||||
for (foo=0; foo<src->height; foo++) {
|
||||
memcpy(dst->Rpix[foo], src->Rpix[foo], src->width);
|
||||
memcpy(dst->Gpix[foo], src->Gpix[foo], src->width);
|
||||
memcpy(dst->Bpix[foo], src->Bpix[foo], src->width);
|
||||
|
|
@ -523,8 +520,7 @@ return 0;
|
|||
/*
|
||||
* no boundary control ?
|
||||
*/
|
||||
int
|
||||
Image_pixel_copy(Image_Desc *s, int x, int y, Image_Desc *d, int i, int j)
|
||||
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];
|
||||
|
|
@ -538,8 +534,7 @@ 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)
|
||||
int Image_compare_desc(Image_Desc *a, Image_Desc *b)
|
||||
{
|
||||
char *fmt = "Image at %p have no 'Dead Beef' in it\n";
|
||||
|
||||
|
|
|
|||
19
Lib/msglib.c
19
Lib/msglib.c
|
|
@ -9,13 +9,11 @@
|
|||
#include "../tthimage.h"
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
char *
|
||||
Image_type2str(int type)
|
||||
char * Image_type2str(int type)
|
||||
{
|
||||
char *pstr;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
switch (type) {
|
||||
case IMAGE_RGB: pstr = "RGB"; break;
|
||||
case IMAGE_RGBA: pstr = "RGBA"; break;
|
||||
case IMAGE_GRAY: pstr = "Gray"; break;
|
||||
|
|
@ -29,14 +27,12 @@ switch (type)
|
|||
return pstr;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
char *
|
||||
Image_err2str(int codeerr)
|
||||
char * Image_err2str(int codeerr)
|
||||
{
|
||||
char *pstr;
|
||||
static char chaine[100];
|
||||
|
||||
switch (codeerr)
|
||||
{
|
||||
switch (codeerr) {
|
||||
case -1: pstr = "error: invalid error"; break;
|
||||
case OLL_KORRECT: pstr = "no error"; break;
|
||||
case 42: pstr = "Universal answer"; break;
|
||||
|
|
@ -114,7 +110,8 @@ switch (codeerr)
|
|||
sprintf(chaine, "error code %d is unknow", codeerr);
|
||||
pstr = chaine;
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "* WTF ? Error %d unknow ?\n", codeerr);
|
||||
fprintf(stderr, "%s: WTF ? Error %d unknow ?\n",
|
||||
__func__, codeerr);
|
||||
#if FORCE_ABORT
|
||||
abort();
|
||||
#endif
|
||||
|
|
@ -125,8 +122,7 @@ return pstr;
|
|||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* new 14 Feb 2000 */
|
||||
void
|
||||
Image_print_error(char * texte, int err)
|
||||
void Image_print_error(char * texte, int err)
|
||||
{
|
||||
FILE *fp;
|
||||
char *errtxt;
|
||||
|
|
@ -145,4 +141,3 @@ fprintf(fp, "%s '%s': %d, %s\n", err ? "Error :" : "Waouh !",
|
|||
fflush(fp);
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
||||
|
|
|
|||
73
Lib/op2x2.c
73
Lib/op2x2.c
|
|
@ -13,12 +13,10 @@
|
|||
* 6 Fev 2001: on aimerait bien avoir la doc de cette fonction
|
||||
* 27 Juillet 2008: on attend toujours...
|
||||
*/
|
||||
int
|
||||
Image_2x2_contours_0(Image_Desc *im)
|
||||
int Image_2x2_contours_0(Image_Desc *im)
|
||||
{
|
||||
int x, y, q;
|
||||
int tbl[] =
|
||||
{
|
||||
int tbl[] = {
|
||||
0, 1, 1, 1,
|
||||
1, 1, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
|
|
@ -29,10 +27,8 @@ int tbl[] =
|
|||
fprintf(stderr, "%s : w=%d h=%d\n", __func__, im->width, im->height);
|
||||
#endif
|
||||
|
||||
for (x=0; x<(im->width-1); x++)
|
||||
{
|
||||
for (y=0; y<(im->height-1); y++)
|
||||
{
|
||||
for (x=0; x<(im->width-1); x++) {
|
||||
for (y=0; y<(im->height-1); y++) {
|
||||
q = ((im->Rpix[y] [x] ? 0 : 1) << 3 ) |
|
||||
((im->Rpix[y] [x+1] ? 0 : 1) << 2 ) |
|
||||
((im->Rpix[y+1][x] ? 0 : 1) << 1 ) |
|
||||
|
|
@ -58,14 +54,13 @@ return OLL_KORRECT;
|
|||
/*::------------------------------------------------------------------::*/
|
||||
/* updated 31 august 2008 */
|
||||
/* le seul bit utilise dans l'image source est le bit 7 */
|
||||
int
|
||||
Image_2x2_contours_1(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_2x2_contours_1(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
int x, y, q;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: err compare %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
#if DEBUG_LEVEL
|
||||
|
|
@ -73,10 +68,8 @@ fprintf(stderr, "*** %s *** catastrophic function :)\n", __func__);
|
|||
#endif
|
||||
Image_clear(dst, 0, 0, 0);
|
||||
|
||||
for (x=0; x<(src->width-1); x++)
|
||||
{
|
||||
for (y=0; y<(src->height-1); y++)
|
||||
{
|
||||
for (x=0; x<(src->width-1); x++) {
|
||||
for (y=0; y<(src->height-1); y++) {
|
||||
q = ((0x80 & (src->Rpix[y] [x] ) ? 0 : 1) << 3 ) |
|
||||
((0x80 & (src->Rpix[y] [x+1]) ? 0 : 1) << 2 ) |
|
||||
((0x80 & (src->Rpix[y+1][x] ) ? 0 : 1) << 1 ) |
|
||||
|
|
@ -101,8 +94,7 @@ return FUNC_IS_BETA;
|
|||
/*
|
||||
* 6 Fev 2001: on aimerait bien avoir la doc de cette fonction
|
||||
*/
|
||||
int
|
||||
Image_2x2_contrast(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_2x2_contrast(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo, x, y, r, g, b;
|
||||
int mir, mig, mib, mar, mag, mab;
|
||||
|
|
@ -110,19 +102,16 @@ int mir, mig, mib, mar, mag, mab;
|
|||
int dx[4] = { 0, 1, 0, 1 };
|
||||
int dy[4] = { 0, 0, 1, 1 };
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: err compare %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=0; y<src->height-1; y++)
|
||||
{
|
||||
for (x=0; x<src->width-1; x++)
|
||||
{
|
||||
for (y=0; y<src->height-1; y++) {
|
||||
for (x=0; x<src->width-1; x++) {
|
||||
mir = mig = mib = 342;
|
||||
mar = mag = mab = -42;
|
||||
for (foo=0; foo<4; foo++)
|
||||
{
|
||||
for (foo=0; foo<4; foo++) {
|
||||
r = (src->Rpix[y+dy[foo]])[x+dx[foo]];
|
||||
g = (src->Gpix[y+dy[foo]])[x+dx[foo]];
|
||||
b = (src->Bpix[y+dy[foo]])[x+dx[foo]];
|
||||
|
|
@ -148,8 +137,7 @@ return FUNC_IS_BETA;
|
|||
/*
|
||||
* 6 Fev 2001: on aimerait bien avoir la doc de cette fonction
|
||||
*/
|
||||
int
|
||||
Image_2x2_lissage(Image_Desc *src, Image_Desc *dst)
|
||||
int Image_2x2_lissage(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo, x, y;
|
||||
int tir, tig, tib;
|
||||
|
|
@ -157,8 +145,8 @@ int tir, tig, tib;
|
|||
int dx[4] = { 0, 1, 0, 1 };
|
||||
int dy[4] = { 0, 0, 1, 1 };
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: err compare %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -166,13 +154,10 @@ if ( (foo=Image_compare_desc(src, dst)) )
|
|||
* attention, il faut bien reflechir avant de tenter d'inverser l'ordre
|
||||
* de parcours en ligne & colonne !
|
||||
*/
|
||||
for (y=0; y<src->height-1; y++)
|
||||
{
|
||||
for (x=0; x<src->width-1; x++)
|
||||
{
|
||||
for (y=0; y<src->height-1; y++) {
|
||||
for (x=0; x<src->width-1; x++) {
|
||||
tir = tig = tib = 0;
|
||||
for (foo=0; foo<4; foo++)
|
||||
{
|
||||
for (foo=0; foo<4; foo++) {
|
||||
tir += (src->Rpix[y+dy[foo]])[x+dx[foo]];
|
||||
tig += (src->Gpix[y+dy[foo]])[x+dx[foo]];
|
||||
tib += (src->Bpix[y+dy[foo]])[x+dx[foo]];
|
||||
|
|
@ -189,20 +174,16 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* 8 Feb 2001: another kludge (without doc)
|
||||
*/
|
||||
int
|
||||
Image_2x2_rot4pix(Image_Desc *src, Image_Desc *dst, int rot)
|
||||
int Image_2x2_rot4pix(Image_Desc *src, Image_Desc *dst, int rot)
|
||||
{
|
||||
int x, y, foo, bar, r, g, b;
|
||||
|
||||
int dx[4] = { 0, 1, 0, 1 };
|
||||
int dy[4] = { 0, 0, 1, 1 };
|
||||
|
||||
for (y=0; y<src->height-1; y+=2)
|
||||
{
|
||||
for (x=0; x<src->width-1; x+=2)
|
||||
{
|
||||
for (foo=0; foo<4; foo++)
|
||||
{
|
||||
for (y=0; y<src->height-1; y+=2) {
|
||||
for (x=0; x<src->width-1; x+=2) {
|
||||
for (foo=0; foo<4; foo++) {
|
||||
bar = (foo+rot)%4;
|
||||
r = (src->Rpix[y+dy[foo]])[x+dx[foo]];
|
||||
g = (src->Gpix[y+dy[foo]])[x+dx[foo]];
|
||||
|
|
@ -225,8 +206,8 @@ int foo;
|
|||
fprintf(stderr, "this func (%s) is a kluge\n", __func__);
|
||||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: err compare %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
|
|||
83
Lib/operat.c
83
Lib/operat.c
|
|
@ -26,8 +26,7 @@
|
|||
/*
|
||||
* XXX il y a un "Zero Divide" cache dans cette fonction !
|
||||
*/
|
||||
int
|
||||
Image_adjust_minmax_0(Image_Desc *src, Image_Desc *dst, int yo,
|
||||
int Image_adjust_minmax_0(Image_Desc *src, Image_Desc *dst, int yo,
|
||||
int minstone, int maxstone)
|
||||
{
|
||||
long histR[256], histG[256], histB[256];
|
||||
|
|
@ -36,8 +35,7 @@ int foo;
|
|||
long mini, maxi, kmini, kmaxi, delta;
|
||||
int idxmini, idxmaxi, val, lut[256], level;
|
||||
|
||||
if (yo != 0)
|
||||
{
|
||||
if (yo != 0) {
|
||||
fprintf(stderr, "Yo is %d\n", yo);
|
||||
}
|
||||
|
||||
|
|
@ -58,11 +56,9 @@ fprintf(stderr, " K maxi = %ld\n", kmaxi);
|
|||
|
||||
mini = 0;
|
||||
idxmini = 0;
|
||||
for (foo=0; foo<256; foo++)
|
||||
{
|
||||
for (foo=0; foo<256; foo++) {
|
||||
mini += (histR[foo] + histG[foo] + histB[foo]);
|
||||
if (mini > kmini)
|
||||
{
|
||||
if (mini > kmini) {
|
||||
fprintf(stderr, "MINI %3d %ld\n", foo, mini);
|
||||
idxmini = foo;
|
||||
break;
|
||||
|
|
@ -71,11 +67,9 @@ for (foo=0; foo<256; foo++)
|
|||
|
||||
maxi = 0;
|
||||
idxmaxi = 255;
|
||||
for (foo=255; foo>=0; foo--)
|
||||
{
|
||||
for (foo=255; foo>=0; foo--) {
|
||||
maxi += (histR[foo] + histG[foo] + histB[foo]);
|
||||
if (maxi > kmaxi)
|
||||
{
|
||||
if (maxi > kmaxi) {
|
||||
fprintf(stderr, "MAXI %3d %ld\n", foo, maxi);
|
||||
idxmaxi = foo;
|
||||
break;
|
||||
|
|
@ -87,8 +81,7 @@ fprintf(stderr, "idxmini=%d idxmaxi=%d delta=%ld\n", idxmini, idxmaxi, delta);
|
|||
|
||||
for (foo=0; foo<idxmini; foo++) lut[foo] = 0;
|
||||
level = 0;
|
||||
for (foo=idxmini; foo<=idxmaxi; foo++)
|
||||
{
|
||||
for (foo=idxmini; foo<=idxmaxi; foo++) {
|
||||
val = (level*255) / delta;
|
||||
lut[foo] = val;
|
||||
level++;
|
||||
|
|
@ -110,27 +103,24 @@ return FUNC_IS_BETA;
|
|||
* et une fonction de plus ecrite a la rache, avec un nom qui
|
||||
* ne veut probablement rien dire :)
|
||||
*/
|
||||
int
|
||||
Image_luminance(Image_Desc *src, Image_Desc *dst, int factor)
|
||||
int Image_luminance(Image_Desc *src, Image_Desc *dst, int factor)
|
||||
{
|
||||
int foo;
|
||||
int x, y;
|
||||
|
||||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "%s ( %p %p %d )\n", __func__, src, dst, factor);
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, factor);
|
||||
#endif
|
||||
|
||||
fprintf(stderr, "luminance factor: %d %f\n", factor, (float)factor / 256.0);
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "Image Luminance: images are differents %d\n", foo);
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
for (x=0; x<src->width; x++)
|
||||
{
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
dst->Rpix[y][x] = (src->Rpix[y][x] * factor) / 256;
|
||||
dst->Gpix[y][x] = (src->Gpix[y][x] * factor) / 256;
|
||||
dst->Bpix[y][x] = (src->Bpix[y][x] * factor) / 256;
|
||||
|
|
@ -156,8 +146,7 @@ return FUNC_IS_BETA;
|
|||
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
|
||||
le parametre 'yoyo' n'est pas utilise actuellement.
|
||||
*/
|
||||
int
|
||||
Image_egalise_RGB(Image_Desc *src, Image_Desc *dst, int yoyo)
|
||||
int Image_egalise_RGB(Image_Desc *src, Image_Desc *dst, int yoyo)
|
||||
{
|
||||
int foo;
|
||||
long *histr, *histg, *histb;
|
||||
|
|
@ -201,8 +190,7 @@ for (foo=0; foo<256; foo++) {
|
|||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "* histo RGB: cumuls: %d %d %d surface: %ld\n",
|
||||
cumlr[255], cumlg[255], cumlb[255], s);
|
||||
for (foo=0; foo<256; foo++)
|
||||
{
|
||||
for (foo=0; foo<256; foo++) {
|
||||
fprintf(stderr, "%3d | %7ld %7ld %7ld | %7d %7d %7d\n",
|
||||
foo,
|
||||
histr[foo], histg[foo], histb[foo],
|
||||
|
|
@ -223,17 +211,15 @@ return 0;
|
|||
|
||||
le parametre 'yoyo' n'est pas utilise actuellement.
|
||||
*/
|
||||
int
|
||||
Image_egalise_mono_0(Image_Desc *src, Image_Desc *dst, int yoyo)
|
||||
int Image_egalise_mono_0(Image_Desc *src, Image_Desc *dst, int yoyo)
|
||||
{
|
||||
int foo;
|
||||
long c, cc, s3;
|
||||
long *histr, *histg, *histb;
|
||||
int cumul[256];
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_Egalise_Mono_0: images are differents %d\n", foo);
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
|
@ -252,8 +238,7 @@ Image_histo_RGB(src, histr, histg, histb);
|
|||
s3 = (3 * src->width * src->height);
|
||||
|
||||
cc = 0L;
|
||||
for (foo=0; foo<256; foo++)
|
||||
{
|
||||
for (foo=0; foo<256; foo++) {
|
||||
c = histr[foo] + histg[foo] + histb[foo];
|
||||
cc += c;
|
||||
cumul[foo] = (int)((cc*255) / s3);
|
||||
|
|
@ -268,17 +253,13 @@ return 0;
|
|||
complement d'une image complete (c.a.d tous
|
||||
les canaux contenus dans cette image)
|
||||
*/
|
||||
int
|
||||
Image_negate(Image_Desc *image, Image_Desc *resultat)
|
||||
int Image_negate(Image_Desc *image, Image_Desc *resultat)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
if (image->type == 3)
|
||||
{
|
||||
for (y=0; y<image->height; y++)
|
||||
{
|
||||
for (x=0; x<image->width; x++)
|
||||
{
|
||||
if (image->type == 3) {
|
||||
for (y=0; y<image->height; y++) {
|
||||
for (x=0; x<image->width; x++) {
|
||||
resultat->Rpix[y][x] = image->Rpix[y][x] ^ 0xff;
|
||||
resultat->Gpix[y][x] = image->Gpix[y][x] ^ 0xff;
|
||||
resultat->Bpix[y][x] = image->Bpix[y][x] ^ 0xff;
|
||||
|
|
@ -287,8 +268,9 @@ if (image->type == 3)
|
|||
return 0;
|
||||
}
|
||||
|
||||
fprintf(stderr, "Image Negate: unknow image type %d, %s\n",
|
||||
image->type, Image_type2str(image->type));
|
||||
fprintf(stderr, "%s: unknow image type %d, %s\n",
|
||||
__func__, image->type, Image_type2str(image->type));
|
||||
|
||||
return IMAGE_BAD_TYPE;
|
||||
}
|
||||
|
||||
|
|
@ -568,27 +550,22 @@ return retval;
|
|||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
||||
int
|
||||
Image_seuil_RGB(Image_Desc *s, Image_Desc *d, int r, int g, int b)
|
||||
int Image_seuil_RGB(Image_Desc *s, Image_Desc *d, int r, int g, int b)
|
||||
{
|
||||
int foo, x, y;
|
||||
|
||||
if ( (s->type != 3) || (d->type != 3) )
|
||||
{
|
||||
if ( (s->type != 3) || (d->type != 3) ) {
|
||||
fprintf(stderr, "Image Seuil RGB: an image is not of type 3\n");
|
||||
return IMAGE_BAD_TYPE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(s, d)) != 0 )
|
||||
{
|
||||
if ( (foo=Image_compare_desc(s, d)) != 0 ) {
|
||||
fprintf(stderr, "Image Seuil RGB: images are differents %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (y=0; y<s->height; y++)
|
||||
{
|
||||
for (x=0; x<s->width; x++)
|
||||
{
|
||||
for (y=0; y<s->height; y++) {
|
||||
for (x=0; x<s->width; x++) {
|
||||
if(s->Rpix[y][x] > r) d->Rpix[y][x] = 255;
|
||||
else d->Rpix[y][x] = 0;
|
||||
if(s->Gpix[y][x] > g) d->Gpix[y][x] = 255;
|
||||
|
|
|
|||
|
|
@ -19,12 +19,10 @@ static Image_Desc *S, *D;
|
|||
static int seuil;
|
||||
static int level, maxlevel;
|
||||
|
||||
static int
|
||||
recursion(Image_Rect *pRect)
|
||||
static int recursion(Image_Rect *pRect)
|
||||
{
|
||||
Image_Rect rect;
|
||||
int h1, h2, w1, w2, xx, yy, foo;
|
||||
|
||||
int mr, mg, mb, dr, dg, db, s;
|
||||
|
||||
level++;
|
||||
|
|
@ -43,13 +41,11 @@ printf(" %7d V %3d %3d %3d D %3d %3d %3d S %3d (%d)\n",
|
|||
pRect->w*pRect->h, mr, mg, mb, dr, dg, db, s, foo);
|
||||
#endif
|
||||
|
||||
if ( (s < seuil) || (pRect->w < 6) || (pRect->h < 6) )
|
||||
{
|
||||
if ( (s < seuil) || (pRect->w < 6) || (pRect->h < 6) ) {
|
||||
Image_paint_rect(D, pRect, mr, mg, mb);
|
||||
/* printf(" paint %d %d %d\n", mr, mg, mb); */
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
Image_paint_rect(D, pRect, 255, 0, 0);
|
||||
/* Image_dump_rect(pRect, "R", 0); */
|
||||
|
||||
|
|
@ -113,10 +109,9 @@ return 0;
|
|||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
* a quoi peut bien servir le parametre ?
|
||||
* a quoi peut bien servir le parametre ?
|
||||
*/
|
||||
int
|
||||
Image_call_recursion_0(Image_Desc *image, Image_Desc *dest, int param)
|
||||
int Image_call_recursion_0(Image_Desc *image, Image_Desc *dest, int param)
|
||||
{
|
||||
Image_Rect rect;
|
||||
int foo;
|
||||
|
|
|
|||
46
Lib/text0.c
46
Lib/text0.c
|
|
@ -30,13 +30,12 @@ static uint8_t priv_fonte[T_FONTE];
|
|||
/*
|
||||
* for now, parameter *ou must be NULL
|
||||
*/
|
||||
int
|
||||
Image_load_fnt8x8(char *nomfnt, uint8_t *ou, int flags)
|
||||
int Image_load_fnt8x8(char *nomfnt, uint8_t *ou, int flags)
|
||||
{
|
||||
int fd, foo;
|
||||
|
||||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "%s: %s %p %d\n", __func__, nomfnt, ou, flags);
|
||||
#if DEBUG_LEVEL > -1
|
||||
fprintf(stderr, ">>> %s ( '%s' %p %d )\n", __func__, nomfnt, ou, flags);
|
||||
#endif
|
||||
|
||||
if (NULL != ou)
|
||||
|
|
@ -51,15 +50,13 @@ if (NULL == nomfnt) {
|
|||
}
|
||||
/* on pourrait aussi mettre la fonte par ddefaut dans l'environ */
|
||||
|
||||
if ( (fd=Image_must_open(nomfnt, O_RDONLY, 0)) < 0 )
|
||||
{
|
||||
if ( (fd=Image_must_open(nomfnt, O_RDONLY, 0)) < 0 ) {
|
||||
perror (nomfnt);
|
||||
exit(5);
|
||||
}
|
||||
|
||||
foo = read(fd, priv_fonte, T_FONTE);
|
||||
if ( foo != T_FONTE )
|
||||
{
|
||||
if ( foo != T_FONTE ) {
|
||||
fprintf(stderr, "%s: error when reading font datas\n", __func__);
|
||||
exit(5);
|
||||
}
|
||||
|
|
@ -75,8 +72,7 @@ return OLL_KORRECT;
|
|||
/*
|
||||
* XXX nasty bug in the alpha channel gestion XXX
|
||||
*/
|
||||
int
|
||||
Image_trace_caractere_2(Image_Desc *im, uint8_t *fnt, int x, int y, int code,
|
||||
int Image_trace_caractere_2(Image_Desc *im, uint8_t *fnt, int x, int y, int code,
|
||||
RGBA *paper, RGBA *ink)
|
||||
{
|
||||
int foo, bar, xi, yi;
|
||||
|
|
@ -88,17 +84,14 @@ fprintf(stderr, "trace car 2: xy= %4d %4d c= %c\n", x, y,
|
|||
isprint(code) ? code : ' ');
|
||||
#endif
|
||||
|
||||
if (NULL==fnt)
|
||||
{
|
||||
if (NULL==fnt) {
|
||||
fnt = priv_fonte; /* use local static storage */
|
||||
}
|
||||
|
||||
for (foo=0; foo<8; foo++)
|
||||
{
|
||||
for (foo=0; foo<8; foo++) {
|
||||
yi = y+foo;
|
||||
octet = fnt[(code*8)+foo];
|
||||
for (bar=0; bar<8; bar++)
|
||||
{
|
||||
for (bar=0; bar<8; bar++) {
|
||||
xi = x+7-bar;
|
||||
|
||||
/* lecture contenu image */
|
||||
|
|
@ -106,14 +99,12 @@ for (foo=0; foo<8; foo++)
|
|||
gs = (im->Gpix[yi])[xi];
|
||||
bs = (im->Bpix[yi])[xi];
|
||||
|
||||
if (octet & 1) /* ENCRE */
|
||||
{
|
||||
if (octet & 1) { /* ENCRE */
|
||||
rp = ((rs*(255-ink->a))+(ink->r*ink->a)) / 255;
|
||||
gp = ((gs*(255-ink->a))+(ink->g*ink->a)) / 255;
|
||||
bp = ((bs*(255-ink->a))+(ink->b*ink->a)) / 255;
|
||||
}
|
||||
else /* PAPIER */
|
||||
{
|
||||
else { /* PAPIER */
|
||||
rp = ((rs*(255-paper->a))+(paper->r*paper->a)) / 255;
|
||||
gp = ((gs*(255-paper->a))+(paper->g*paper->a)) / 255;
|
||||
bp = ((bs*(255-paper->a))+(paper->b*paper->a)) / 255;
|
||||
|
|
@ -131,17 +122,14 @@ return 42;
|
|||
/*
|
||||
* fonction très primitive...
|
||||
*/
|
||||
int
|
||||
Image_trace_caractere(Image_Desc *im, int x, int y, int code)
|
||||
int Image_trace_caractere(Image_Desc *im, int x, int y, int code)
|
||||
{
|
||||
int foo, bar;
|
||||
uint8_t octet;
|
||||
|
||||
for (foo=0; foo<8; foo++)
|
||||
{
|
||||
for (foo=0; foo<8; foo++) {
|
||||
octet = priv_fonte[(code*8)+foo];
|
||||
for (bar=0; bar<8; bar++)
|
||||
{
|
||||
for (bar=0; bar<8; bar++) {
|
||||
if (octet & 1)
|
||||
Image_plotRGB(im, x+8-bar, y+foo, 255, 255, 255);
|
||||
else
|
||||
|
|
@ -214,11 +202,9 @@ fprintf(stderr, "encre %3d %3d %3d %3d\n", ink->r, ink->g, ink->b, ink->a);
|
|||
#endif
|
||||
|
||||
posx = x; posy = y;
|
||||
for (foo=0; foo<t_texte; foo++)
|
||||
{
|
||||
for (foo=0; foo<t_texte; foo++) {
|
||||
octet = ptrtxt[foo];
|
||||
if (posx > (im->width-8))
|
||||
{
|
||||
if (posx > (im->width-8)) {
|
||||
fprintf(stderr, "can't plot char '%c' at x=%d\n", octet, posx);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -213,11 +213,12 @@ int Image_t16x24_pltstr_1(Image_Desc *img, char *str, int x, int y,
|
|||
{
|
||||
int len, foo;
|
||||
|
||||
len = strlen(str);
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "%s: '%s' at %d,%d\n", __func__, str, x, y);
|
||||
fprintf(stderr, ">>> %s: '%s' at %d,%d\n", __func__, str, x, y);
|
||||
#endif
|
||||
|
||||
len = strlen(str);
|
||||
|
||||
for (foo=0; foo<len; foo++) {
|
||||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "%4d %c\n", foo, str[foo]);
|
||||
|
|
@ -225,7 +226,8 @@ for (foo=0; foo<len; foo++) {
|
|||
Image_t16x24_pltch_1(img, str[foo], x+(foo*16), y, paper, ink, flags);
|
||||
}
|
||||
|
||||
return FUNC_IS_BETA;
|
||||
/* XXX return FUNC_IS_BETA; */
|
||||
return 0;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
|
|
|||
|
|
@ -0,0 +1,30 @@
|
|||
/*
|
||||
* trigo.c
|
||||
*
|
||||
* nouveau Thu 15 Sep 2022 09:33:53 PM CEST
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifdef NEED_ALLOCA_H
|
||||
#include <alloca.h>
|
||||
#endif
|
||||
|
||||
#include "../tthimage.h"
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
Image_cos010(Image_Desc *src, Image_Desc *dst)
|
||||
{
|
||||
int foo;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) ) {
|
||||
fprintf(stderr, "%s: images not compatible, %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return FULL_NUCKED;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
|
@ -22,7 +22,7 @@ HTML_DIR=$(DESTDIR)/html
|
|||
# use -Wmissing-prototypes ?
|
||||
|
||||
LIBIMG_OPT=-DFORCE_ABORT=1 -DDEBUG_LEVEL=0 -DIMGCOMMENT=0
|
||||
CC_OPTS=-Wall -W -g -ansi -O3 -fPIC -no-pie
|
||||
CC_OPTS=-Wall -W -g -pg -ansi -O3 -fPIC -no-pie
|
||||
CC_HACKS=-DNEED_ALLOCA_H
|
||||
CFLAGS= $(CC_OPTS) \
|
||||
$(LIBIMG_OPT) \
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
http:///la.buvette.org/devel/libimage/
|
||||
*/
|
||||
#ifndef IMAGE_VERSION_STRING
|
||||
#define IMAGE_VERSION_STRING "0.4.51 pl 21"
|
||||
#define IMAGE_VERSION_STRING "0.4.51 pl 28"
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
|
|
|
|||
Loading…
Reference in New Issue