FloatImg/tools/fimgfx.c

/*
		FIMGFX
*/
#include  <stdio.h>
#include  <string.h>
#include  <stdlib.h>
#include  <unistd.h>

#include  "../floatimg.h"

/* --------------------------------------------------------------------- */

int			verbosity;
float			global_fvalue;

typedef struct {
	char		*name;
	int		id;
	int		nbarg;
	int		flags;
	} Fx;

enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
		Fx_rot90,
		Fx_xper };

Fx fx_list[] = {
	{ "cos01",		Fx_cos01,	0,	1 },
	{ "cos010",		Fx_cos010,	0,	1 },
	{ "pow2",		Fx_pow2,	0,	1 },
	{ "sqrt",		Fx_sqrt,	0,	1 },
	{ "gray0",		Fx_gray0,	0,	1 },
	{ "halfsz0",		Fx_halfsz0,	0,	1 },
	{ "rot90",		Fx_rot90,	0,	0 },
	{ "xper",		Fx_xper,	0,	1 },
	{ NULL,			0,	0 }
	};

/* --------------------------------------------------------------------- */
int lookup_fxidx(char *txt)
{
Fx		*fx;
int		n;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, txt);
#endif

for (n=0, fx=fx_list; fx->name; fx++, n++) {
#if DEBUG_LEVEL > 1
	fprintf(stderr, "  -> %3d %s\n", n, fx->name);
#endif
	if (!strcmp(fx->name, txt)) {
		return n;
		}
	}
return -1;		/* NOT FOUND */
}
/* --------------------------------------------------------------------- */
int do_experiment(FloatImg *S, FloatImg *D, float kf)
{
int		foo;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %f )\n", __func__, S, D, kf);
#endif

foo = fimg_copy_data(S, D);
if (foo) {
	fprintf(stderr, "%s err %d copy data %p -> %p\n", __func__,
				foo, 		S, D);
	return -98;
	}

foo = fimg_killcolors_a(D, kf);
if (foo) {
	fprintf(stderr, "%s err %d killcolors %p %f\n", __func__,
				foo, 		S, kf);
	return -98;
	}

return 0;
}
/* --------------------------------------------------------------------- */
static void help(int lvl)
{
Fx		*fx;

printf("-- fimg special effects -- %s %s --\n", __DATE__, __TIME__);
puts("usage:");
puts("\tfimgfx [options] <effect> source.fimg resultat.fimg");

puts("options:");
puts("\t-k N.N\tset the floating value");
puts("\t-v\tincrease verbosity");

puts("effects:"); 
printf("\t");
for (fx=fx_list; fx->name; fx++) {
	printf("%s ", fx->name);
	}
puts("");
fimg_print_version(1);
exit(0);
}
/* --------------------------------------------------------------------- */
int do_an_effect(char *sf, int fxidx, char *df)
{
FloatImg	src, dest;
int		foo, action;
double		maxval;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %d '%s' )\n", __func__,
			   sf, action, df);
#endif

foo = fimg_create_from_dump(sf, &src);
if (foo) {
	fprintf(stderr, "err load '%s' : %d\n", sf, foo);
	return foo;
	}

maxval = (double)fimg_get_maxvalue(&src);

if (fx_list[fxidx].flags & 1) {
	foo = fimg_clone(&src, &dest, 0);
	if (foo) {
		fprintf(stderr, "err clone %p : %d\n", &src, foo);
		return foo;
		}
	}
else	{
	/* XXX */
	memset(&dest, 0, sizeof(dest));
	}

action = fx_list[fxidx].id;

switch (action) {
	case Fx_cos01:
		fimg_cos_01(&src, &dest, maxval);		break;
	case Fx_cos010:
		fimg_cos_010(&src, &dest, maxval);		break;
	case Fx_pow2:
		fimg_power_2(&src, &dest, maxval);		break;
	case Fx_sqrt:
		fimg_square_root(&src, &dest, maxval);		break;

	case Fx_gray0:		/* new 2020 01 10 */
		fimg_to_gray(&src); fimg_copy_data(&src, &dest);
								break;

	case Fx_xper:
		do_experiment(&src, &dest, maxval);		break;
		
	case Fx_rot90:
		foo = fimg_rotate_90(&src, &dest, 0);		break;
		
	case Fx_halfsz0:
		fprintf(stderr, "halfsize was not implemented\n");
		return -3;

	default:
		fprintf(stderr, "%s %s : %d is bad action\n",
					__FILE__, __func__, action);
		break;

	}

foo = fimg_dump_to_file(&dest, df, 0);
if (foo) {
	fprintf(stderr, "dumping datas to file give us a %d\n", foo);
	return foo;
	}

return 0;
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int		foo, opt, action;
int		nba;
char		*operator;

char		*srcname = "";
char		*dstname = "out.fimg";

while ((opt = getopt(argc, argv, "hk:v")) != -1) {
	switch(opt) {
		case 'h':	help(0);			break;
		case 'k':	global_fvalue = atof(optarg);	break;
		case 'v':	verbosity++;			break;
		}
	}

#if DEBUG_LEVEL
fprintf(stderr, "argc %d optind %d\n", argc, optind);
for (foo=0; foo<argc; foo++)
	fprintf(stderr, "%3d  %c  %s\n", foo, foo==optind?'*':' ', argv[foo]);
#endif

if (3 > argc-optind) {
	fprintf(stderr, "%s need some arguments...\n", argv[0]);
	exit(1);
	}

operator = argv[optind];
action = lookup_fxidx(operator);
if (action < 0) {
	fprintf(stderr, "garbage found in opcode field : %s\n", operator);
	exit(1);
	}

if (verbosity) {
	fprintf(stderr, "  global fvalue  %f\n", global_fvalue);
	fprintf(stderr, "  action         %d\n", action);
	fprintf(stderr, "  verbosity      %d\n", verbosity);
	}

if ((nba=fx_list[action].nbarg)) {
	fprintf(stderr, "action '%s' need %d arg\n", operator, nba);
	}

srcname = argv[optind+1];
dstname = argv[optind+2];
if (verbosity) fprintf(stderr, "%s  ==>  %s\n", srcname, dstname);

foo = do_an_effect(srcname, action, dstname);
if (foo) {
	fprintf(stderr, "do an effect -> %d\n", foo);
	}

return 0;
}
/* --------------------------------------------------------------------- */