323 lines
7.8 KiB
C
323 lines
7.8 KiB
C
/*
|
|
+---------------------------------------+
|
|
| Effets speciaux sur les images |
|
|
| troisieme module |
|
|
+---------------------------------------+
|
|
Thierry Boudet <oulala@chez.com>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h> /* yo ! */
|
|
|
|
#include "../tthimage.h"
|
|
|
|
/*::------------------------------------------------------------------::*/
|
|
/*
|
|
* 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 foo, x, y, r, g, b;
|
|
int cr, cg, cb;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "*** Effect X_0: coeffs: %d %d %d\n", kr, kg, kb);
|
|
#endif
|
|
|
|
if ( (foo=Image_compare_desc(src, dst)) ) {
|
|
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
|
return foo;
|
|
}
|
|
|
|
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); */
|
|
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 ++;
|
|
}
|
|
if (g > kg) {
|
|
foo = r; r = b; b = foo;
|
|
cg ++;
|
|
}
|
|
if (b > kb) {
|
|
foo = g; g = r; r = foo;
|
|
cb ++;
|
|
}
|
|
/* 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); */
|
|
|
|
return FUNC_IS_BETA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/* 2 fevrier 2003: je fait du n'importe quoi, la... */
|
|
/*
|
|
* 3 avril 2007: je me rend compte que les parametres ne servent a rien.
|
|
*/
|
|
int 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, "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++) {
|
|
r = src->Rpix[y][x];
|
|
g = src->Gpix[y][x];
|
|
b = src->Bpix[y][x];
|
|
|
|
/* 2 fevrier 2003: je fait du n'importe quoi, la... */
|
|
dst->Rpix[y][x] = g^b;
|
|
dst->Gpix[y][x] = r^b;
|
|
dst->Bpix[y][x] = r^g;
|
|
}
|
|
}
|
|
|
|
return FUNC_IS_BETA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/*
|
|
* 1er Fevrier 2003: encore une autre experimentation, qui va etre
|
|
* basee sur la trigonometrie.
|
|
*/
|
|
int 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, "%s: images are differents %d\n", __func__, foo);
|
|
return foo;
|
|
}
|
|
|
|
/* a vrai dire, je ne comprend pas ou caser kx, ky et kz */
|
|
|
|
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];
|
|
|
|
/*
|
|
* je scale chacune des composantes entre 0.0 et 1.0
|
|
*/
|
|
dr = ( (double)r ) / 255.0;
|
|
dg = ( (double)g ) / 255.0;
|
|
db = ( (double)b ) / 255.0;
|
|
|
|
/*
|
|
* en fait c'est pas du tout ce que je pense faire,
|
|
* mais bon, faut tout essayer...
|
|
*/
|
|
ar = atan2(dg, db);
|
|
ag = atan2(dr, db);
|
|
ab = atan2(dr, dg);
|
|
|
|
/*
|
|
* et la il y a des soucis d'echelle :)
|
|
* 15 mars 2005: pourquoi 156 ? (XXX)
|
|
*/
|
|
r = (int)(ar * 156.0);
|
|
g = (int)(ag * 156.0);
|
|
b = (int)(ab * 156.0);
|
|
|
|
dst->Rpix[y][x] = r;
|
|
dst->Gpix[y][x] = g;
|
|
dst->Bpix[y][x] = b;
|
|
}
|
|
}
|
|
|
|
return FUNC_IS_BETA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/*
|
|
* 30 Jan 2003: hop, j'improvise pendant que les patates cuisent :)
|
|
* 4 Fev 2003: et je peaufine pendant que le poulet mijote :)
|
|
* 27 Oct 2003: je debugge pendant que le the infuse :)
|
|
* 16 Mai 2005: je commence a ecrire la documentation.
|
|
* 29 sept 2015: je devrais finir la doc d'ici 2 ans.
|
|
* 19 aout 2022: je comprend pas ce que c'est cense faire :)
|
|
*
|
|
*/
|
|
int Image_effect_x_3(Image_Desc *src, Image_Desc *dst, int kx, int ky, char *comp)
|
|
{
|
|
int foo, sx, sy;
|
|
int x, y, r, g, b;
|
|
int cx, cy, dx, dy;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "%s : kx %d ky %d comp '%s'\n", __func__, kx, ky, comp);
|
|
#endif
|
|
|
|
if ( (foo=Image_compare_desc(src, dst)) ) {
|
|
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
|
return foo;
|
|
}
|
|
|
|
if (strlen(comp) != 2) {
|
|
fprintf(stderr, "%s: bad comp parameter '%s'\n", __func__, comp);
|
|
fprintf(stderr, " must be a 2 chars string, from 'rgb'\n");
|
|
return INVALID_PARAM;
|
|
}
|
|
|
|
/*
|
|
* conversion en minuscules des deux lettres de composantes
|
|
*/
|
|
cx = tolower(comp[0]); cy = tolower(comp[1]);
|
|
dx = dy = 0;
|
|
sx = sy = 0;
|
|
|
|
/*
|
|
* ici il faudrait une validation des deux lettres, mais j'ai la
|
|
* flemme d'ecrire ce genre de chos maintenant.
|
|
* Je vais plutot aller boofer.
|
|
*/
|
|
|
|
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];
|
|
|
|
switch(cx) {
|
|
case 'r': dx = r; break;
|
|
case 'g': dx = g; break;
|
|
case 'b': dx = b; break;
|
|
}
|
|
switch(cy) {
|
|
case 'r': dy = r; break;
|
|
case 'g': dy = g; break;
|
|
case 'b': dy = b; break;
|
|
}
|
|
|
|
sx = x + ((kx * (dx-128)) / 100);
|
|
sy = y + ((ky * (dy-128)) / 100);
|
|
|
|
if ( sx >= 0 && sx < dst->width &&
|
|
sy >= 0 && sy < dst->height ) {
|
|
r = src->Rpix[sy][sx];
|
|
g = src->Gpix[sy][sx];
|
|
b = src->Bpix[sy][sx];
|
|
Image_plotRGB(dst, x, y, r, g, b);
|
|
}
|
|
else {
|
|
Image_plotRGB(dst, x, y, r, r, r);
|
|
}
|
|
/*
|
|
* Je suis vraiment confus, mais je n'y comprend RIEN :)
|
|
*/
|
|
}
|
|
}
|
|
|
|
return FUNC_IS_ALPHA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
int Image_effect_x_4(Image_Desc *src, Image_Desc *dst, int flags)
|
|
{
|
|
int foo;
|
|
int x, y;
|
|
int r, g, b, r2, g2, b2;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "*** effect x4 is not ready for prime time ***\n");
|
|
#endif
|
|
|
|
if ( (foo=Image_compare_desc(src, dst)) ) {
|
|
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++) {
|
|
r = src->Rpix[y][x];
|
|
g = src->Gpix[y][x];
|
|
b = src->Bpix[y][x];
|
|
r2 = r; g2 = g; b2 = b;
|
|
|
|
if (flags & 1) {
|
|
if (r > g) b2 = (r + g) / 2;
|
|
if (b > g) r2 = (b + g) / 2;
|
|
if (r > b) g2 = (r + b) / 2;
|
|
}
|
|
else {
|
|
if (r < g) b2 = (r + g) / 2;
|
|
if (b < g) r2 = (b + g) / 2;
|
|
if (r < b) g2 = (r + b) / 2;
|
|
}
|
|
|
|
Image_plotRGB(dst, x, y, r2, g2, b2);
|
|
}
|
|
}
|
|
|
|
return FUNC_IS_BETA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/* 22 avril 2007: je vais essayer d'inventer un nouveau truc, mais il
|
|
* faudrait que les gosses arretent de ma casser les oreilles avec leur
|
|
* machine a batailles. putain de gamecube... */
|
|
/* 23 aout 2022 : j'ai bien envie d'une SNES et d'un Trinitron */
|
|
int Image_effect_x_5(Image_Desc *src, Image_Desc *dst, int kx, int ky, int kz)
|
|
{
|
|
int foo, sx, sy;
|
|
int x, y, r, g, b;
|
|
int r2, g2, b2;
|
|
double dr, dg, db, dr2, dg2, db2;
|
|
|
|
fprintf(stderr, "*** effect x5 is not ready for prime time ***\n");
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p %p %d %d %d )\n", __func__, src, dst,
|
|
kx, ky, kz);
|
|
#endif
|
|
|
|
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++) {
|
|
r = src->Rpix[y][x];
|
|
g = src->Gpix[y][x];
|
|
b = src->Bpix[y][x];
|
|
dr = (double)r / 255.0;
|
|
dg = (double)g / 255.0;
|
|
db = (double)b / 255.0;
|
|
dr2 = pow(dg, db);
|
|
dg2 = pow(db, dr);
|
|
db2 = pow(dr, dg);
|
|
r2 = (int)(dr2 * 255.0);
|
|
g2 = (int)(dg2 * 255.0);
|
|
b2 = (int)(db2 * 255.0);
|
|
#if DEBUG_LEVEL
|
|
if (x==42 && y==42) {
|
|
printf("{{{ pixels %3d %3d %3d }}}\n", r, g, b);
|
|
printf("{{{ result %3d %3d %3d }}}\n", r2, g2, b2);
|
|
}
|
|
#endif
|
|
Image_plotRGB(dst, x, y, r2, g2, b2);
|
|
}
|
|
}
|
|
|
|
return FUNC_IS_ALPHA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|