.4.51 pl 28
This commit is contained in:
1 parent
20754c17e9
commit
dec52079cd
51 files changed
+273
-377
No files matched your search
+21
-2
@@ -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
|
||||
|
||||
???
|
||||
Whitespace-only changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
+2
-1
@@ -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
|
||||
|
||||
+8
-16
@@ -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,8 +382,7 @@ 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)
|
||||
{
|
||||
|
||||
+37
-65
@@ -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);
|
||||
|
||||
|
||||
+7
-16
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
+23
-27
@@ -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);
|
||||
}
|
||||
|
||||
+45
-84
@@ -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,18 +390,14 @@ 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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+6
-11
@@ -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";
|
||||
|
||||
|
||||
+7
-12
@@ -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);
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
||||
+27
-46
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
+30
-53
@@ -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;
|
||||
|
||||
+4
-9
@@ -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); */
|
||||
|
||||
@@ -115,8 +111,7 @@ return 0;
|
||||
/*
|
||||
* 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;
|
||||
|
||||
+16
-30
@@ -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;
|
||||
}
|
||||
|
||||
+5
-3
@@ -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;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*::------------------------------------------------------------------::*/
|
||||
|
||||
+30
@@ -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;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*::------------------------------------------------------------------::*/
|
||||
+1
-1
@@ -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) \
|
||||
|
||||
+1
-1
@@ -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"
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
|
||||
Reference in new issue
Block a user