FloatImg/funcs/t.c

/*
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include  <pam.h>



#include "../floatimg.h"

int		verbosity;

float		global_fvalue;

/* --------------------------------------------------------------------- */
/*
 *	nouveau 7 octobre 2020 pendant sonoptic
 */

int essai_qsort_rgb(char *infile)
{
FloatImg	src, dst;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "%s : loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
	abort();
	}

fimg_clone(&src, &dst, 1);

foo = fimg_qsort_rgb_b(&src, &dst, 0);
if (foo) {
	fprintf(stderr, "%s: err %d in qsort_rgb\n", __func__, foo);
	return foo;
	}

foo = fimg_dump_to_file(&dst, "out.fimg", 0);
if (foo) {
	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
	return foo;
	}

return 0;
}

/* --------------------------------------------------------------------- */
/*
 *	nouveau 5 octobre 2020 pendant sonoptic
 */
int essai_contour_2x2(char *infile)
{
FloatImg	src, dst;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "%s : loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
	abort();
	}

fimg_clone(&src, &dst, 1);

foo = fimg_contour_2x2(&src, &dst, 0);
if (foo) {
	fprintf(stderr, "%s: err %d in contour_2x2\n", __func__, foo);
	return foo;
	}

foo = fimg_save_as_pnm(&dst, "out.pnm", 0);
if (foo) {
	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
	return foo;
	}

return 0;
}
/* --------------------------------------------------------------------- */
/*
 *	nouveau 5 octobre 2020 pendant sonoptic
 */
int essai_classif(char *infile)
{
FloatImg	src, dst;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "%s : loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
	abort();
	}

fimg_clone(&src, &dst, 1);

fprintf(stderr, "%s : fvalue is %f\n", __func__, global_fvalue);

foo = fimg_classif_trial(&src, &dst, global_fvalue, 0);
if (foo) {
	fprintf(stderr, "%s: err %d in classif_trial\n", __func__, foo);
	return foo;
	}

foo = fimg_save_as_pnm(&dst, "out.pnm", 0);
if (foo) {
	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
	return foo;
	}

return 0;
}
/* --------------------------------------------------------------------- */
/* nouveau 19 aout 2020, le matin avant la canicule */

int essai_ecriture_tiff(char *outname)
{
int		foo;
FloatImg	picz;

fimg_create(&picz, 800, 600, FIMG_TYPE_RGB);
fimg_test_pattern(&picz, 0, 22222);

foo = fimg_write_as_tiff(&picz, outname, 0);
if (foo) {
	fprintf(stderr, "%s got a %d\n", __func__, foo);
	return foo;
	}

return -7;
}
/* --------------------------------------------------------------------- */
/*	essai de fichiers FITS (astronomie)				*/
int essai_ecriture_fits(char *outname)
{
FloatImg	src;
int		foo;

fprintf(stderr, "%s is creating the picz\n", __func__);
fimg_create(&src, 512, 512, FIMG_TYPE_RGB);
fimg_test_pattern(&src, 0, 255.0);

foo = fimg_save_R_as_fits(&src, outname, 0);

fprintf(stderr, "saving '%s' to fits --> %d\n", outname, foo);

return -1;
}
/* --------------------------------------------------------------------- */
/*
 *	egalisation dynamique approximative
 *	#coronamaison  Thu 09 Apr 2020 03:37:10 PM CEST
 */
int essai_equalize(char *infile)
{
FloatImg	src;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "%s: loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
	abort();
	}

foo = fimg_equalize_compute(&src, NULL, 666.666);
fprintf(stderr, "equalize compute --> %d\n", foo);

fimg_destroy(&src);

return -1;
}
/* --------------------------------------------------------------------- */
int essai_rotate(char *infile)
{
FloatImg	src, dst;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "%s: loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
	abort();
	}

fimg_save_as_png(&src, "test.png", 0);

foo = fimg_rotate_90(&src, &dst, 0);
fprintf(stderr, "rotate 90 -> %d\n", foo);

foo = fimg_save_as_png(&dst, "rotated90.png", 0);
foo = fimg_save_as_pnm(&dst, "rotated90.pnm", 0);

fimg_destroy(&src);

return -1;
}
/* --------------------------------------------------------------------- */
int essai_filtrage_3x3(char *infile)
{
FloatImg	src, dst;
int		foo;			/// , idx;
// char		buffer[100];

FimgFilter3x3	filter_a =  {

	{	1.0,	1.0,	1.0,
		1.0,   -3.0,	1.0,
		1.0,	1.0,	1.0 },
		8.0, 0.0

	};

FimgFilter3x3	filter_b =  {

	{	-2.0,	-1.0,	0.0,
		-1.0,    3.0,	1.0,
		0.0,	 1.0,	2.0 },
		8.0, 0.0

	};

if (NULL != infile) {
	fprintf(stderr, "%s: loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &src);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s is creating the picz\n", __func__);
	fimg_create(&src, 640, 480, FIMG_TYPE_RGB);
	fimg_test_pattern(&src, 0, 255.0);
	}

// fimg_save_as_png(&src, "test.png", 0);

foo = fimg_clone(&src, &dst, 0);
if (foo) {
	fprintf(stderr, "%s: err clone %p\n", __func__, &src);
	return -44;
	}


fimg_filter_3x3(&src, &dst, &filter_a);


foo = fimg_clamp_negativ(&dst);

if (foo) {
	fprintf(stderr, "clamped %d negative pixels\n", foo);
	}
// foo = fimg_save_as_png(&dst, "f3x3a.png", 0);
// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);

fimg_filter_3x3(&src, &dst, &filter_b);
foo = fimg_clamp_negativ(&dst);
if (foo) {
	fprintf(stderr, "clamped %d negative pixels\n", foo);
	}
// foo = fimg_save_as_png(&dst, "f3x3b.png", 0);
// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);

fimg_destroy(&src);	fimg_destroy(&dst);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_filtrage_2x2(char *infile)
{
FloatImg	fimg;
int		foo, idx;
char		buffer[100];

if (NULL != infile) {
	fprintf(stderr, "%s: loading %s\n", __func__, infile);
	foo = fimg_create_from_dump(infile, &fimg);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fprintf(stderr, "%s is creating the picz\n", __func__);
	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
	fimg_draw_something(&fimg);
	}

foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);

/*
 *	running multiple filters so you can
 *	watch the up-left shift :)
 */
for (idx=0; idx<5; idx++) {
	foo = fimg_lissage_2x2(&fimg);
	sprintf(buffer, "filter%03d.png", idx);
	foo = fimg_save_as_png(&fimg, buffer, 0);
	if (verbosity) {
		fprintf(stderr, "%s %d\n", buffer, foo);
		}
	}

fimg_destroy(&fimg);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_geometrie(char *infile)
{
FloatImg	fimg, result;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "loading %s\n", infile);
	foo = fimg_create_from_dump(infile, &fimg);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
	fimg_draw_something(&fimg);
	}

foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);

memset(&result, 0, sizeof(FloatImg));

foo = fimg_halfsize_0(&fimg, &result, 0);
fprintf(stderr, "retour halfsize -> %d\n", foo);
if (foo) {
	return -2;
	}

if (verbosity) fimg_describe(&result, "result after halfsize");

foo = fimg_save_as_pnm(&result, "something.pnm", 0);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_sfx0(char *infile)
{
FloatImg	fimg;
int		foo;

if (NULL != infile) {
	fprintf(stderr, "loading %s\n", infile);
	foo = fimg_create_from_dump(infile, &fimg);
	if (foo) {
		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
		return foo;
		}
	}
else	{
	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
	fimg_draw_something(&fimg);
	}

foo = fimg_save_as_pnm(&fimg, "something.pnm", 0);
if (foo) {
	fprintf(stderr, "%s: err save %d\n", __func__, foo);
	return -6;
	}
foo = fimg_killcolors_a(&fimg, 0.0);
foo = fimg_save_as_pnm(&fimg, "colorskilled-a.pnm", 0);
if (foo) {
	fprintf(stderr, "%s: err save %d\n", __func__, foo);
	return -6;
	}

foo = fimg_killcolors_b(&fimg, 0.0);
foo = fimg_save_as_pnm(&fimg, "colorskilled-b.pnm", 0);
if (foo) {
	fprintf(stderr, "%s: err save %d\n", __func__, foo);
	return -6;
	}


return 0;
}
/* --------------------------------------------------------------------- */
int essai_parse_double(void)
{
int		foo;
double		dval;
char		*str;

str = "12.34";	dval = 0.0;
foo = parse_double(str, &dval);
printf("%-10s -> %3d   %g\n", str, foo, dval);

str = "12e4";	dval = 0.0;
foo = parse_double(str, &dval);
printf("%-10s -> %3d   %g\n", str, foo, dval);

str = "5s";	dval = 0.0;
foo = parse_double(str, &dval);
printf("%-10s -> %3d   %g\n", str, foo, dval);

str = "PORN";	dval = 0.0;
foo = parse_double(str, &dval);
printf("%-10s -> %3d   %g\n", str, foo, dval);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_detect_type(void)
{
int		foo;
char		*fname;

foo = format_from_extension(fname="foo.fimg");
printf("%-10s %d\n\n", fname, foo);

foo = format_from_extension(fname="foo.pnm");
printf("%-10s %d\n\n", fname, foo);

foo = format_from_extension(fname="foo.png");
printf("%-10s %d\n\n", fname, foo);

foo = format_from_extension(fname="foo.xyzzy");
printf("%-10s %d\n\n", fname, foo);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_mire(char *outname, int notused)
{
FloatImg	fimg;
int		re;

fimg_create(&fimg, 1280, 960, FIMG_TYPE_RGB);

re = fimg_test_pattern(&fimg, 9, 1.0);
if (re) {
	fprintf(stderr, "fimg_test_pattern -> %d\n", re);
	}
fimg_save_as_pnm(&fimg, "mire.pnm", 0);

return -1;
}
/* --------------------------------------------------------------------- */
int essai_rampes(void)
{
FloatImg	fimg;
int		foo;

fimg_create(&fimg, 640, 480, FIMG_TYPE_RGB);

foo = fimg_hdeg_a(&fimg, (double)3.141592654);
fprintf(stderr, "make h deg -> %d\n", foo);
foo = fimg_save_as_pnm(&fimg, "hdeg.pnm", 0);
fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);

foo = fimg_vdeg_a(&fimg, (double)3.141592654);
fprintf(stderr, "make h deg -> %d\n", foo);
foo = fimg_save_as_pnm(&fimg, "vdeg.pnm", 0);
fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);

return 0;
}
/* --------------------------------------------------------------------- */
int essai_ecriture_png(char *fname)
{
FloatImg	fimg;
int		foo;

fimg_create(&fimg, 800, 600, FIMG_TYPE_RGB);

fimg_draw_something(&fimg);

if (verbosity) {
	foo = fimg_save_as_pnm(&fimg, "quux.pnm", 0);
	fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);
	}

foo = fimg_save_as_png(&fimg, fname, 0);
fprintf(stderr, "save as png -> %d\n", foo);

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

		
int fimg_essai_histo(FloatImg *src, char *outpic, int k); /* histogram.c */
int fimg_essai_hsv(char *fname);				/* hsv.c */


int essai_histogramme(char *fname, int k)
{
FloatImg	fimg;
int		foo;

fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, k);

foo = fimg_create_from_dump(fname, &fimg);
if (foo) {
	fprintf(stderr, "%s: err load '%s'\n", __func__, fname);
	return foo;
	}

foo = fimg_essai_histo(&fimg, "out.png", k);
if (foo) {
	fprintf(stderr, "essai_histo -> error %d\n", foo);
	return foo;
	}

fimg_destroy(&fimg);

fprintf(stderr, "\\o/ end of %s\n", __func__);

return 0;
}
/* --------------------------------------------------------------------- */
enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
			Histo, Hsv, Classif, Ctr2x2, Qsortrgb  };
typedef struct {
	char	*name;
	int	Cmd;
	} Command;

Command commands[] = {
	{ "equalize",	Equalize	},
	{ "rotate",	Rotate		},
	{ "sfx0",	Sfx0		},
	{ "f3x3",	F3x3		},
	{ "mire",	MIRE		},
	{ "wfits",	Wfits		},
	{ "wpng",	Wpng		},
	{ "wtiff",	Wtiff		},
	{ "histo",	Histo		},
	{ "hsv",	Hsv		},
	{ "classif",	Classif		},
	{ "ctr2x2",	Ctr2x2		},
	{ "qsortrgb",	Qsortrgb	},
	{ NULL,		0		}
	} ;

/* --------------------------------------------------------------------- */
int lookup_cmd(char *cmdtxt)
{
Command *pcmd;

pcmd = commands;
while (pcmd->name) {
	if (!strcmp(pcmd->name, cmdtxt)) return pcmd->Cmd;
	pcmd++;
	}

return -1;
}
/* --------------------------------------------------------------------- */
void help(int k)
{
Command *pcmd;

fprintf(stderr, "usage:\n\t./t command filename\n");

fprintf(stderr, "commands:\n");
pcmd = commands;
while (pcmd->name) {
	fprintf(stderr, "\t%-15s   %d\n", pcmd->name, pcmd->Cmd);
	pcmd++;
	}
fprintf(stderr, "\ncompiled on "__DATE__" at "__TIME__"\n");

exit(0);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int		foo, opt;
char		*filename, *command;

fprintf(stderr, "++++++++ test des fonctions pid=%d\n", getpid());

global_fvalue = 1.0;

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;
		}
	}

// fprintf(stderr, "argc %d   optind %d\n", argc, optind);

filename = NULL;
if (2 != argc-optind) {
	fprintf(stderr, "%s: bad command line\n", argv[0]);
	help(1);
	}

command  = argv[optind];
filename = argv[optind+1];

if (verbosity) {
	fprintf(stderr, "%s : running command '%s' on '%s'\n",
				argv[0], command, filename);
	fprintf(stderr, "global fvalue : %f\n", global_fvalue);
	}

opt = lookup_cmd(command);
// fprintf(stderr, "lookup '%s' --> %d\n", command, opt);

switch(opt) {
	case Equalize:
		foo = essai_equalize(filename);		break;

	case Sfx0:
		foo = essai_sfx0(filename);		break;
	case F3x3:
		foo = essai_filtrage_3x3(filename);	break;

	case MIRE:
		foo = essai_mire(filename, 0);
		break;
	case Wfits:
		foo =  essai_ecriture_fits(filename);
		break;
	case Wpng:
		foo = essai_ecriture_png(filename);
		break;
	case Wtiff:
		foo = essai_ecriture_tiff(filename);
		break;
	case Histo:
		foo = essai_histogramme(filename, 98765);
		break;
	case Hsv:
		foo = fimg_essai_hsv(filename);
		break;
	case Classif:
		foo = essai_classif(filename);
		break;
	case Ctr2x2:
		foo = essai_contour_2x2(filename);
		break;
	case Qsortrgb:
		foo = essai_qsort_rgb(filename);
		break;
	default:
		fprintf(stderr, "%s : bad command\n", command);
		exit(1);

	}

if (foo) {
	fprintf(stderr, "Essai ====> %d\n", foo);
	}

fprintf(stderr, "++++++++++++++ end of pid %d\n", getpid());
return 0;
}
/* --------------------------------------------------------------------- */