tTh
/
libtthimage
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
libtthimage/Lib/combine.c

450 lines
9.0 KiB
C
Raw Normal View History

second massive import batch
2022-06-26 11:06:35 +02:00
/*
combine.c others effects
========= --------------
made by Thierry Boudet, aka "Oulala", aka "Tonton Th".
ces fonctions combinent de diverses fa<EFBFBD>ons deux images
de memes dimensions. on pourra, par exemple, les utiliser
pour comparer deux traitements.
*/
#include <stdio.h>
#include <stdlib.h>
third massive import batch
2022-06-27 00:48:18 +02:00
#include "../tthimage.h"
second massive import batch
2022-06-26 11:06:35 +02:00
#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#endif
/*::------------------------------------------------------------------::*/
/*
* le param<EFBFBD>tre 'zak' n'est pas utilis<EFBFBD> et doit <EFBFBD>tre mis <EFBFBD> 0
*/
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;
if (sy == 0)
{
fprintf(stderr, "Combine Lines: sy is zer0 and zak is %d\n", zak);
return DIVISOR_IS_ZERO;
}
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine Lines: sources are differents (%d)\n", foo);
return foo;
}
#if DEBUG_LEVEL
fprintf(stderr, "Combine lines: %d %d\n", sy, oy);
#endif
for (y=0; y<s1->height; y++)
{
my = (y+oy) / sy;
for (x=0; x<s1->width; x++)
{
if ( my&1 )
{
r = (s1->Rpix[y])[x];
g = (s1->Gpix[y])[x];
b = (s1->Bpix[y])[x];
}
else
{
r = (s2->Rpix[y])[x];
g = (s2->Gpix[y])[x];
b = (s2->Bpix[y])[x];
}
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/
/*
* le param<EFBFBD>tre 'zak' n'est pas utilis<EFBFBD> et doit <EFBFBD>tre mis <EFBFBD> 0
*/
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;
if (sx == 0)
{
fprintf(stderr, "Combine Columns: sx is zer0\n");
return DIVISOR_IS_ZERO;
}
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine Lines: sources are differents (%d)\n", foo);
return foo;
}
#if DEBUG_LEVEL
fprintf(stderr, "Combine columns: %d %d\n", sx, ox);
#endif
for (y=0; y<s1->height; y++)
{
for (x=0; x<s1->width; x++)
{
mx = (x+ox) / sx;
if ( mx&1 )
{
r = (s1->Rpix[y])[x];
g = (s1->Gpix[y])[x];
b = (s1->Bpix[y])[x];
}
else
{
r = (s2->Rpix[y])[x];
g = (s2->Gpix[y])[x];
b = (s2->Bpix[y])[x];
}
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
d->modified = 1;
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/
/*
* 28 Jan 2001: pourquoi ne pas introduire un calcul automatique
* des coefficients ox & oy pour obtenir le centrage ?
*
* 'zak' parameter is not used, and must be 0.
*/
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;
int x, y, mx, my;
#if DEBUG_LEVEL
fprintf(stderr, "Checker (%p, %p) -> %p [%d,%d] [%d,%d]\n",
s1, s2, d, sx, sy, ox, oy);
#endif
if (zak)
{
fprintf(stderr, "%s: param 'zak' = %d, must be 0.\n", __func__,
zak);
}
if ( sx==0 || sy==0 )
{
fprintf(stderr, "Combine Checker: sx or sy is Zero\n");
return DIVISOR_IS_ZERO;
}
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine Checker: sources are differents (%d)\n", foo);
return foo;
}
for (y=0; y<s1->height; y++)
{
my = (y+oy) / sy;
for (x=0; x<s1->width; x++)
{
mx = (x+ox) / sx;
if ( (mx&1) != (my&1) )
{
r = (s1->Rpix[y])[x];
g = (s1->Gpix[y])[x];
b = (s1->Bpix[y])[x];
}
else
{
r = (s2->Rpix[y])[x];
g = (s2->Gpix[y])[x];
b = (s2->Bpix[y])[x];
}
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
return 0;
}
/*::------------------------------------------------------------------::*/
/*::------------------------------------------------------------------::*/
/*
* houba, celle-ci va me donner du mal, et on peut la
* considerer comme pas finie, c'est a dire, entre autre,
* que le prototype risque de changer.
*
* Toutes les suggestions sont les bienvenues, surtout si
* elles viennent de glandeur06 et son UltraSparc.
*
* 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 foo;
int xcenter, ycenter;
int x, y, r1, v1, b1, r2, b2, v2;
float fx2, fy2, dmax, coef;
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine Cercle Flou: differents sources (%d)\n", foo);
return foo;
}
if ( (foo=Image_compare_desc(s1, d)) )
{
fprintf(stderr, "Combine Cercle Flou: source != dest (%d)\n", foo);
return foo;
}
xcenter = (s1->width) / 2;
ycenter = (s1->height) / 2;
dmax = (float)(xcenter*xcenter) + (float)(ycenter*ycenter);
dmax /= 1.732;
#if DEBUG_LEVEL
fprintf(stderr, "\tcentre: %d, %d\n", xcenter, ycenter);
fprintf(stderr, "\tdmax: %f\n", dmax);
fflush(stderr); /* vraiment necessaire ? */
#endif
for (y=0; y<s1->height; y++)
{
fy2 = (float)((y-ycenter)*(y-ycenter));
for (x=0; x<s1->width; x++)
{
fx2 = (float)((x-xcenter)*(x-xcenter));
r1 = (s1->Rpix[y])[x];
v1 = (s1->Gpix[y])[x];
b1 = (s1->Bpix[y])[x];
r2 = (s2->Rpix[y])[x];
v2 = (s2->Gpix[y])[x];
b2 = (s2->Bpix[y])[x];
coef = (fx2+fy2)/dmax;
if (coef < 0.0) coef = 0.0;
if (coef > 1.0) coef = 1.0;
(d->Rpix[y])[x] = (int)(r1*(1.0-coef)+r2*coef);
(d->Gpix[y])[x] = (int)(v1*(1.0-coef)+v2*coef);
(d->Bpix[y])[x] = (int)(b1*(1.0-coef)+b2*coef);
}
}
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/
/*
* le flag 'yo' decide quelle image sera en haut <EFBFBD> droite.
* les param<EFBFBD>tres p1 & p2 ne sont pas utilis<EFBFBD>s.
*/
int
Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
int yo, int p1, int p2)
{
int foo;
int x, y, r, g, b;
int vertical, offset;
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine Diagonale: differents sources (%d)\n", foo);
return foo;
}
if (s1->height > s1->width)
{
vertical = 1;
offset = (s1->height - s1->width) / 2;
}
else
{
vertical = 0;
offset = (s1->width - s1->height) / 2;
}
for (y=0; y<s1->height; y++)
{
for (x=0; x<s1->width; x++)
{
if ( vertical )
{
if (x > (y-offset)) foo=1;
else foo=0;
}
else
{
if ((x-offset) > y) foo=1;
else foo=0;
}
foo = yo ? !foo : foo; /* strange hack */
if (foo)
{
r = (s1->Rpix[y])[x];
g = (s1->Gpix[y])[x];
b = (s1->Bpix[y])[x];
}
else
{
r = (s2->Rpix[y])[x];
g = (s2->Gpix[y])[x];
b = (s2->Bpix[y])[x];
}
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
/*
* 30 sept 2008 : est-ce que cette fonction a subi un bon fuzzing ?
*/
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/
/* 15 Nov 2000
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 foo, x, y, r, g, b;
int r1, r2, g1, g2, b1, b2;
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine MinMax: differents sources (%d)\n", foo);
return foo;
}
for (y=0; y<s1->height; y++)
{
for (x=0; x<s1->width; x++)
{
r1 = (s1->Rpix[y])[x];
g1 = (s1->Gpix[y])[x];
b1 = (s1->Bpix[y])[x];
r2 = (s2->Rpix[y])[x];
g2 = (s2->Gpix[y])[x];
b2 = (s2->Bpix[y])[x];
if (flg)
{
r = max(r1, r2);
g = max(g1, g2);
b = max(b1, b2);
}
else
{
r = min(r1, r2);
g = min(g1, g2);
b = min(b1, b2);
}
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/
/*
* fonction faite pour le finisseur de DBvsEE
*
* 6 oct 2001: une version qui permettrait de sp<EFBFBD>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 foo, x, y, r, g, b;
if ( (foo=Image_compare_desc(s1, s2)) )
{
fprintf(stderr, "Combine If Not Black: differents sources (%d)\n", foo);
return foo;
}
for (y=0; y<s1->height; y++)
{
for (x=0; x<s1->width; x++)
{
/* XXX Image_getRGB(s1, x, y, &r, &g, &b); */
r = (s1->Rpix[y])[x];
g = (s1->Gpix[y])[x];
b = (s1->Bpix[y])[x];
if ( r==0 && g==0 && b==0 )
{
/* XXX Image_getRGB(s2, x, y, &r, &g, &b); */
r = (s2->Rpix[y])[x];
g = (s2->Gpix[y])[x];
b = (s2->Bpix[y])[x];
}
/*Image_plotRGB(d, x, y, r, g, b);*/
(d->Rpix[y])[x] = r;
(d->Gpix[y])[x] = g;
(d->Bpix[y])[x] = b;
}
}
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,
Image_Rect *za, Image_Rect *zb,
Image_Desc *dst)
{
int foo;
/* Image_Rect rect; */
if ( (foo=Image_compare_desc(src, dst)) )
{
fprintf(stderr, "Poke 2 Zone: src & dst: %d %s\n",
foo, Image_err2str(foo));
return foo;
}
Image_copy(src, dst);
fprintf(stderr, "Image Poke 2 Zones: ben, ya rien...\n");
return FUNC_NOT_FINISH;
}
/*::------------------------------------------------------------------::*/