check for the export directory (singlepass)

check for the export directory (interpolator)
check for the export directory (fonderie)
2024-11-13 13:37:54 +01:00 · 2024-11-13 13:35:22 +01:00 · 2024-11-12 22:58:55 +01:00 · 2024-11-12 12:50:31 +01:00 · 2024-11-12 12:49:43 +01:00 · 2024-11-12 11:36:57 +01:00
85 changed files with 1584 additions and 529 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -30,15 +30,6 @@ doc/*.ind
 doc/co*.tex
 doc/foo.html

-funcs/t
-funcs/*.o
-funcs/*.png
-funcs/V/*
-funcs/*.gif
-funcs/*.fits
-funcs/*.tiff
-funcs/toto
-
 scripts/*.fimg
 scripts/*.pnm
 scripts/*.gif
--- a/Fonderie/Makefile
+++ b/Fonderie/Makefile
@@ -7,12 +7,12 @@ COPT = -g -fpic -no-pie -Wall -DDEBUG_LEVEL=0 -Werror=parentheses
 LIBS = ../libfloatimg.a -ltiff -lpnglite -lm -lz -lcfitsio

 OBJS = fifo.o sfx.o crapulator.o glitches.o metriques.o	\
-	filterstack.o single.o
+	filterstack.o single.o utilfuncs.o

 DEPS = 	../floatimg.h						\
 	../libfloatimg.a					\
 	fifo.h crapulator.h metriques.h glitches.h sfx.h	\
-	filterstack.h crapdef.h crapstr.h single.h
+	filterstack.h crapdef.h crapstr.h single.h utilfuncs.h

 all:	fonderie interpolator singlepass t

@@ -71,4 +71,7 @@ metriques.o:	metriques.c metriques.h Makefile
 glitches.o:	glitches.c glitches.h Makefile
 	gcc ${COPT} -c $<

+utilfuncs.o:	utilfuncs.c utilfuncs.h Makefile
+	gcc ${COPT} -c $<
+
 # ---------------------------------------------------------
--- a/Fonderie/README.md
+++ b/Fonderie/README.md
@@ -3,12 +3,14 @@
 Avec toutes ces fonctions disponibles et `grabvidseq`, nous
 savons faire des images **floues**. L'étape suivante, les plus
 pervers d'entre vous le savent déja, est celle de la création
-de **films flous** dans le domaine spacio-temporel. 
+de **films flous** dans le domaine spatio-temporel. 

 À l'heure actuelle, il y a plusieurs programmes distincts. Le premier
 (fonderie) fait une moyenne mobile sur N images consécutives,
-et le second (interpolator) fait un fondu-enchainé de N pas
-entre deux images consécutives.
+le second (interpolator) fait un fondu-enchainé de N pas
+entre deux images consécutives,
+et le troisième (singlepass) fait d'autres trucs, comme
+répéter N fois un image pour avoir une vidéo sacadée.

 Mais avant et après un de ces deux traitements, il y a des chaines
 de filtres...
@@ -72,6 +74,8 @@ GLOB=${GRABDIR}'/?????.fimg'
 ${FONDEUR} -I "$GLOB" -E cos01:trinitron -F classtrial -T 30
 ```

+Par défaut le répertoire où sont exportées les images est nommé
+`p8/` et il doit être là, c'est donc à vous de le créer.
 Votre machine va maintenant mouliner avec entrain et persévérance,
 puis
 ensuite il vous suffira d'encoder toutes les images générées dans
@@ -94,7 +98,7 @@ assez rudimentaire, avec un paramétrage simpliste, et un manque
 criant de documentation...

 Dans la même équipe, vous pouvez aussi aller contempler `glitches.c`
-pour voir le genre de traitement que l'on fait subir à nox pixels
+pour voir le genre de traitement que l'on fait subir à nos pixels
 flottants.

 ## Interpolator
@@ -111,8 +115,8 @@ usage:
        interpolator [options] <inglob> <outdir> <nbsteep>
 options:
        -S nn           mysterious sort
-        -E i:bla:k      input  filter chain
-        -F name:j       output filter chain
+        -E foo:bla:kr   input  filter chain
+        -F name:just    output filter chain
        -L              list available filters
        -v              increase verbosity
 ```
@@ -129,6 +133,7 @@ usage:
        -F      define:the:filter:chain
        -g      input glob pattern
        -L      list available filters
+        -r N    repetiiing factor
        -O      /output/directory
        -v      spit more messages
 ```
--- a/Fonderie/craplist2str.awk
+++ b/Fonderie/craplist2str.awk
@@ -17,7 +17,7 @@ BEGIN	{
 #
 	{
 	name = sprintf("CR_%s", $2)
-	printf "   { %-12s,  \"%s\",       %d, %f }, // #%d\n",
+	printf "   { %-14s,  \"%s\",       %d, %f },      // #%d\n",
                        name,    $2,   $3, $4,           $1;
 	}

--- a/Fonderie/crapulator.c
+++ b/Fonderie/crapulator.c
@@ -200,6 +200,20 @@ if (verbosity > 1) fprintf(stderr, "in %s, pixelize H rnd -> %d\n",
 fimg_copy_data(&tmp, img);
 fimg_destroy(&tmp);

+return ret;
+}
+/* -------------------------------------------------------------- */
+/* added Mon Apr  1 15:56:54 UTC 2024 */
+static int run_triptyq(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+ret = fimg_make_triptyq(img, &tmp, k);
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
 return ret;
 }
 /* -------------------------------------------------------------- */
@@ -250,12 +264,37 @@ static int run_decomprgbz_gray(FloatImg *img, int k)
 FloatImg		tmp;
 int			ret;

+/* ugly code here */
 memset(&tmp, 0, sizeof(FloatImg));
 fimg_clone(img, &tmp, 0);
 ret = fimg_decomp_rgbz_gray(img, &tmp, k);
 fimg_copy_data(&tmp, img);
 fimg_destroy(&tmp);

+return ret;
+}
+/* -------------------------------------------------------------- */
+/* new Sun Jul 16 11:27:43 UTC 2023 */
+int run_suprbg(FloatImg *img, int notused)
+{
+FloatImg		tmp;
+int			ret;
+
+if (notused) {
+	fprintf(stderr, "FATAL: invalid notused in %s\n", __func__);
+	abort();
+	}
+
+/* ugly code here */
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+ret = poke_sup_rb_g(img, &tmp);
+if (ret) { 
+	fprintf(stderr, "%s: ret = %d\n", __func__, ret);
+	}
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
 return ret;
 }
 /* -------------------------------------------------------------- */
@@ -454,10 +493,33 @@ switch (idFx) {
 		break;

 	case CR_fluffy:
-		// fprintf(stderr, "******* TO BE DONE ********\n");
 		retval = run_rndfluffy(image, 75);
 		break;

+	case CR_suprbg:
+		retval = run_suprbg(image, 0);
+		break;
+
+	case CR_thermocol:
+		/* new Wed Mar 20 19:42:42 UTC 2024 */
+		retval = fimg_auto_thermique(image, image, 0);
+		break;
+
+	case CR_triptyq:
+		/* added  Mon Apr  1 15:52:32 UTC 2024*/
+		retval = run_triptyq(image, 0);
+		break;
+
+	case CR_togray:
+		retval = fimg_to_gray(image);
+		break;
+
+	case CR_shift0:
+		/* added Sun Sep 29 16:55:54 UTC 2024 */
+		retval = fimg_auto_shift_to_zero(image, image);
+		// fprintf(stderr, "******** Shift Zero -> %d\n", retval);
+		break;
+
 	default :
 		fprintf(stderr, "%s : effect #%d invalid\n", 
 				__func__, idFx);
@@ -494,7 +556,13 @@ int		idx;

 #define OUT	stdout

-if (NULL!=texte && verbosity) fprintf(OUT, "___ %s ___\n", texte);
+if (verbosity) {
+	fprintf(stderr, "We have around %ld filters now !\n", NBCRAP);
+	}
+
+if (NULL!=texte && verbosity)
+	fprintf(OUT, " _________ %s _________\n", texte);
+
 for (idx=0; CrapL[idx].id!=-1; idx++) {
 	if (verbosity) {
 		fprintf(OUT, " %-12s | %4d  |  %5d  |  %8.3f\n",
--- a/Fonderie/crapulors.liste
+++ b/Fonderie/crapulors.liste
@@ -43,4 +43,10 @@
 51	decrgbzg	1	99
 60	gr2popcol	1	99
 61	fluffy		1	0.12
+62	suprbg		1	0
+80	thermocol	1	0
+81	triptyq		1	0
+90	togray		1	0
+91	shift0		1	0
 -1	end		1	1.0
+
--- a/Fonderie/fifo.c
+++ b/Fonderie/fifo.c
@@ -87,7 +87,7 @@ return 0;
 */
 int export_fifo(char *fname, int notused)
 {
-int		foo, type;
+int		foo;

 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
@@ -118,7 +118,7 @@ return 0;
 int insert_picture(FloatImg *src)
 {
 FloatImg	*dst;
-int		nbre, foo;
+int		nbre;

 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p )\n", __func__, src);
--- a/Fonderie/fonderie.c
+++ b/Fonderie/fonderie.c
@@ -10,6 +10,7 @@
 #include  <glob.h>
 #include  "../floatimg.h"

+#include  "utilfuncs.h"
 #include  "fifo.h"
 #include  "glitches.h"
 #include  "crapulator.h"
@@ -108,7 +109,7 @@ fprintf(stderr, "glob '%s' -> %d, %d files found\n", pattern, foo,
 /*	get the size of the inputs images */
 foo = fimg_fileinfos(globbuf.gl_pathv[0], datas);
 width = datas[0];		height = datas[1];
-fprintf(stderr, "first image size %dx%d\n", width, height);
+if (verbosity) fprintf(stderr, "first image size %dx%d\n", width, height);

 fimg_create(&input, width, height, 3);

@@ -120,10 +121,10 @@ if (foo) {
 	exit(1);
 	}
 maxvalue = fimg_get_maxvalue(&input);
-fprintf(stderr, "first image maxvalue %f\n", maxvalue);
+if (verbosity) fprintf(stderr, "first image maxvalue %f\n", maxvalue);

 foo = create_fifo(szfifo, width, height, FIMG_TYPE_RGB);
-fprintf(stderr, "init fifo (%d slots) --> %d\n", szfifo, foo);
+if (verbosity) fprintf(stderr, "init fifo (%d slots) = %d\n", szfifo, foo);

 /* XXX inject a few strange pics in the fifo */
 insert_blank(&input, blk, outdir);
@@ -186,10 +187,12 @@ puts("\t-F\toutput:filter:chain");
 // puts("\t-g\tconvert to gray");
 puts("\t-I\tinput glob pattern");
 puts("\t-L\tlist available filters");
-puts("\t-O\toutput directory");
+puts("\t-O\toutput directory (default p8/)");
 puts("\t-T\tfifo size");
 puts("\t-v\tincrease verbosity");

+if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
+
 exit(0);
 }
 /* -------------------------------------------------------------- */
@@ -200,13 +203,12 @@ int		fifosize = 10;
 char		*in_pattern = "capture/?????.fimg";
 char		*out_dir = "p8";
 int		outfmt = FILE_TYPE_PNG;
-int		blanks = 20;
+int		blanks = 10;
 char		*InFchain  = "none";
 char		*OutFchain = "none";

 fprintf(stderr, "*** %s\n\tcompiled %s, %s, pid %d\n",
 			argv[0], __DATE__, __TIME__, getpid());
-fimg_print_version(2);

 while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
 	switch(opt) {
@@ -238,6 +240,16 @@ if (verbosity) {
 	fprintf(stderr, "\toutput dir        '%s'\n", out_dir);
 	fprintf(stderr, "\tsrc filter        '%s'\n", InFchain);
 	fprintf(stderr, "\tout filter        '%s'\n", OutFchain);
+	fprintf(stderr, "\tfifo size         %d\n",   fifosize);
+	}
+/*
+ *	check for the export directory
+ */
+foo = check_if_export_dir_is_valid(out_dir, 0);
+if ( !foo ) {
+	fprintf(stderr, "** export dir (%s) not valid\n", out_dir);
+	fprintf(stderr, "** may be you have to create it ?\n");
+	exit(1);
 	}

 foo = parse_filter_chain(0, InFchain);
@@ -259,7 +271,7 @@ if (verbosity > 1) {

 foo = demarre_la_machine(in_pattern, out_dir, fifosize, outfmt, blanks);

-fprintf(stderr, "retour du big-run de la machine -> %d\n", foo);
+fprintf(stderr, "retour du bigrun de la machine -> %d\n", foo);

 return 0;
 }
--- a/Fonderie/interpolator.c
+++ b/Fonderie/interpolator.c
@@ -17,6 +17,7 @@

 #include  "../floatimg.h"

+#include  "utilfuncs.h"
 #include  "fifo.h"
 #include  "glitches.h"
 #include  "crapulator.h"
@@ -54,12 +55,12 @@ char		*filename;
 IdxValue	*idxvalues;

 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, ptr_glob,
-				ptr_idxval, method);
+fprintf(stderr, ">>> %s ( %p %p %d %p)\n", __func__, ptr_glob,
+				ptr_idxval, method, p_average);
 #endif

-if (0 == method) {
-	fprintf(stderr, "\tWTF? in %s, method was ZERO?\n", __func__);
+if (0==method && verbosity) {
+	fprintf(stderr, "\tWTF? in %s, sort method was ZERO?\n", __func__);
 	}

 nombre = ptr_glob->gl_pathc;
@@ -140,8 +141,8 @@ foo = glob(pattern, 0, NULL, &globbuf);
 fprintf(stderr, "    globbing '%s' -> %d, %d files found\n",
 			pattern, foo, (int)globbuf.gl_pathc);
 if (0 == globbuf.gl_pathc) {
-	fprintf(stderr, "%s : no file found, aborting\n", __func__);
-	return -1;
+	fprintf(stderr, "%s : no file found, ABEND\n", __func__);
+	exit(1);
 	}

 idx_values = NULL;
@@ -159,7 +160,7 @@ if (FIMG_TYPE_RGB != iarray[2]) {
 	}

 w = iarray[0], h = iarray[1];
-fprintf(stderr, "first image size : %dx%d\n", w, h);
+if (verbosity) fprintf(stderr, "first image size : %dx%d\n", w, h);

 fimg_create(&A,   w, h, 3);	pFirst  = &A;	fimg_clear(&A);
 fimg_create(&B,   w, h, 3);	pSecond = &B;	fimg_clear(&B);
@@ -176,7 +177,8 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
 				(int)globbuf.gl_pathc, cptr);
 	foo = fimg_load_from_dump(cptr, &B);
 	if (foo) {
-		fprintf(stderr, "load %s from dump -> %d\n", cptr, foo);
+		fprintf(stderr, "\n%s: load %s from dump -> %d\n", __func__,
+						cptr, foo);
 		continue;
 		}

@@ -239,9 +241,7 @@ puts("\t-S nn\t\tmysterious sort");
 puts("\t-L\t\tlist available filters");
 puts("\t-v\t\tincrease verbosity");

-if (verbosity) {
-	list_crapulors("available filters");
-	}
+if (verbosity) { puts(""); fimg_print_version(2); puts(""); }

 exit(0);
 }
@@ -256,10 +256,11 @@ int		opt;
 int		sort = 0;
 char		*InFchain  = "0";
 char		*OutFchain = "0";
+char		*out_dir = "p8/";

-fprintf(stderr, "*** %s\n\tcompiled by tTh, %s %s\n", argv[0],
+fprintf(stderr, "*** %s\n\tcompiled on %s %s\n", argv[0],
 			__DATE__, __TIME__);
-fimg_print_version(2);
+if (verbosity) fimg_print_version(2);

 #if DEBUG_LEVEL
 /* this is for the debug off calling shellscript */
@@ -291,6 +292,18 @@ if (3 != (argc-optind)) {
 	exit(1);
 	}

+out_dir = argv[optind+1];
+
+/*
+ *	check for the export directory
+ */
+foo = check_if_export_dir_is_valid(out_dir, 0);
+if ( !foo ) {
+	fprintf(stderr, "** export dir (%s) not valid\n", out_dir);
+	fprintf(stderr, "** may be you have to create it ?\n");
+	exit(1);
+	}
+
 foo = parse_filter_chain(0, InFchain);
 if (foo) {
 	fprintf(stderr, "err %d parsing '%s'\n", foo, InFchain);
--- a/Fonderie/sfx.c
+++ b/Fonderie/sfx.c
@@ -21,6 +21,52 @@
 */
 extern	int		verbosity;

+/* -------------------------------------------------------------- */
+/* new Sun Mar 31 22:31:31 UTC 2024				  */
+
+int add_a_border_0(FloatImg *src, FloatImg *dst)
+{
+
+fprintf(stderr, "****** %s:%s to be implemented\n", __FILE__, __func__);
+
+exit(1);
+}
+/* -------------------------------------------------------------- */
+/*
+ * nouveau Sun Jul 16 07:37:22 UTC 2023
+ *
+ *	may-be this can be an on-place function ?
+ *
+ */
+int poke_sup_rb_g(FloatImg *src, FloatImg *dst)
+{
+int		idx, nbpix, foo;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
+#endif
+
+if ( (foo=fimg_images_not_compatible(src, dst)) )
+	{
+	fprintf(stderr, "%s: no compat %d\n", __func__, foo);
+	return foo;
+	}
+
+nbpix = src->width * src->height;
+if (verbosity > 1)
+	fprintf(stderr, "%s work on %d pixels\n", __func__, nbpix);
+
+for (idx=0; idx<nbpix; idx++) {
+	dst->R[idx] = src->R[idx];
+	dst->B[idx] = src->B[idx];
+	if (src->R[idx] < src->B[idx])
+		dst->G[idx] = src->R[idx];
+	else
+		dst->G[idx] = src->B[idx];
+	}
+
+return 0;
+}
 /* -------------------------------------------------------------- */
 /* nouveau 14 mai 2022 rue Ernest Renan */

@@ -91,6 +137,9 @@ static int pixel_trinitron(FloatImg *pimg, int pos[4], float *fvals)
 int		x, y, pline, off;
 int		ym;

+// fprintf(stderr, ">>> %s ( %p  %d,%d,%d,%d )\n", __func__, pimg,
+//			pos[0], pos[1], pos[2], pos[3]);
+
 fimg_clear_rectangle(pimg, pos);

 ym = pos[1]+pos[3]-1;
@@ -101,6 +150,7 @@ for (y=pos[1]; y<ym; y++) {
 	pline = y*pimg->width;
 	for (x=0; x<5; x++) {
 		off = pline + (x+pos[0]);
+
 		/* wtf i'm doing here ? */
 		if ( (pos[1]==y) || (ym-1==y) ) {
 			pimg->R[off]    = fvals[0] * FDIM;
@@ -143,21 +193,22 @@ fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
 *   And this mistake is all around the code /o\
 *
 */
-#define STP  8			/* stepd for x & y axex */
+#define STP  15			/* stepd for x & y axex */
 coo[2] = coo[3] = STP;

-for (y=0; y < pimg->height; y+=STP) {
+for (y=0; y < pimg->height-STP; y+=STP) {
 	coo[1] = y;
-	for (x=0; x < pimg->width; x+=STP) {
+	for (x=0; x < pimg->width-STP; x+=STP) {
 		coo[0] = x;
 		foo = stat_zone(pimg, coo, vals);
 		if (foo)	abort();
-		/* next step : plot the datas */
-		// XXX fprintf(stderr, "%s    %6d    %6d\n", __func__, x, y);
 		pixel_trinitron(pimg, coo, vals);
 		}
 	}
 #undef STP
+
+// fprintf(stderr, "   end trinitron\n");		// XXX
+
 return 0;
 }
 /* -------------------------------------------------------------- */
@@ -389,8 +440,9 @@ int des_bords_sombres_b(FloatImg *pimg, int nbre)
 {
 int		idx, x, foo;
 float		coef, *fptr;
+
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, offset);
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, nbre);
 #endif

 for (idx=0; idx<nbre; idx++) {
--- a/Fonderie/sfx.h
+++ b/Fonderie/sfx.h
@@ -7,6 +7,7 @@ int graylevel2popcolors(FloatImg *src, FloatImg *dst, int k);

 int incrustation_vignette(FloatImg *src, FloatImg *dst, int k);

+int poke_sup_rb_g(FloatImg *src, FloatImg *dst);

 int trinitron(FloatImg *pimg, int notused);

--- a/Fonderie/single.c
+++ b/Fonderie/single.c
@@ -51,7 +51,7 @@ if (foo) {
 	return -2;
 	}
 if (S_IFDIR != (stbuf.st_mode & S_IFMT)) {
-	fprintf(stderr, "! %s must be a directory\n", dest);
+	fprintf(stderr, "%s: %s must be a directory\n", __func__, dest);
 	return -3;
 	}

--- a/Fonderie/singlepass.c
+++ b/Fonderie/singlepass.c
@@ -13,6 +13,7 @@

 #include  "../floatimg.h"

+#include  "utilfuncs.h"
 #include  "crapulator.h"
 #include  "filterstack.h"
 #include  "single.h"
@@ -84,17 +85,21 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
 	else	{
 		foo = fimg_load_from_dump(fname, &image);
 		}
+	if (verbosity > 1) {
+		fprintf(stderr, "%s: image '%s' loaded in %p\n",
+					__func__, fname, &image);
+		}
 	if (foo) {
 		fprintf(stderr, "get image -> %d\n", foo);
 		return -1;
 		}

-	if (0 == idx) {
-		fprintf(stderr, "image size %dx%d\n",
+	if (0==idx && verbosity) {
+		fprintf(stderr, "\tfirst image size %dx%d\n",
 					image.width, image.height);
 		}

-	fprintf(stderr, "  %6ld  %s\r", (long)globbuf.gl_pathc-idx, fname);
+	// fprintf(stderr, "  %6ld  %s\r", (long)globbuf.gl_pathc-idx, fname);

 	foo = filterstack_run(fchain, &image, 0);
 	if (foo) {
@@ -113,7 +118,7 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
 		}
 	}

-fprintf(stderr, "\n\n");
+fprintf(stderr, "\n");

 globfree(&globbuf);

@@ -157,7 +162,7 @@ int		repeat = 1;

 fprintf(stderr, "*** %s\n\tcompiled %s %s\n", argv[0],
                        __DATE__, __TIME__);
-fimg_print_version(2);
+if (verbosity) fimg_print_version(2);

 if (argc < 2) {
 	fprintf(stderr, "\t/!\\ %s is option driven\n", argv[0]);
@@ -187,7 +192,6 @@ while ((opt = getopt(argc, argv, "hF:g:LO:r:svx")) != -1) {
 			fprintf(stderr, "%s ABEND\n", argv[0]);
 			exit(1);
 		}
-
 	}

 if (repeat < 1) {
@@ -195,6 +199,13 @@ if (repeat < 1) {
 	exit(2);
 	}

+foo = check_if_export_dir_is_valid(outdir, 0);
+if ( !foo ) {
+	fprintf(stderr, "** export dir (%s) not valid\n", outdir);
+	fprintf(stderr, "** may be you have to create it ?\n");
+	exit(1);
+	}
+
 foo = parse_filter_chain(FILTERS, filterchain);
 if (foo) {
 	fprintf(stderr, "err %d in parse_filter_chain\n", foo);
@@ -216,7 +227,7 @@ if (verbosity) {
 */
 foo = run_the_singlepass(globbing, outdir, repeat,
 					FILTERS, FILE_TYPE_PNG);
-fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
+fprintf(stderr, "\tRun the single pass --> %d\n", foo);

 return 0;
 }
--- a/Fonderie/t.c
+++ b/Fonderie/t.c
@@ -16,6 +16,8 @@
 #include  "crapulator.h"
 #include  "single.h"

+#include  "utilfuncs.h"
+
 /* ----------------------------------------------------------- */

 int		verbosity;
@@ -28,6 +30,30 @@ int		verbosity;

 #define		STK	6

+/* ----------------------------------------------------------- */
+/* new Sat Nov  9 22:17:46 UTC 2024 */
+int essai_test_export_dir(char *footxt)
+{
+int		foo;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' )\n", __func__, footxt);
+#endif
+
+foo = check_if_export_dir_is_valid("/tmp/quux", 0);
+fprintf(stderr, "    got %d\n\n", foo);
+
+foo = check_if_export_dir_is_valid("/home", 0);
+fprintf(stderr, "    got %d\n\n", foo);
+
+foo = check_if_export_dir_is_valid("./", 0);
+fprintf(stderr, "    got %d\n\n", foo);
+
+foo = check_if_export_dir_is_valid("Makefile", 0);
+fprintf(stderr, "    got %d\n\n", foo);
+
+return -1;
+}
 /* ----------------------------------------------------------- */

 int essai_filterstack(char *fIname, char *fOname)
@@ -36,11 +62,16 @@ int		foo;
 FloatImg	image;
 double		debut, fin;

+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' '%s' )\n", __func__, fIname, fOname);
+#endif
+
+
 // filterstack_list(STK, __func__);

 foo = fimg_create_from_dump(fIname, &image);
 if (foo) {
-	fprintf(stderr, "err %d create image\n", foo);
+	fprintf(stderr, "%s: err %d create from dump\n", __func__, foo);
 	exit(1);
 	}

@@ -73,8 +104,6 @@ return 0;

 foo = essayer_single("capture/???42.fimg", "/tmp/x8/", STK);
 fprintf(stderr, "essayer single -> %d\n", foo);
-
-
 */
 int essayer_single(char *globpattern, char *destdir, int chain)
 {
@@ -161,14 +190,14 @@ puts("\t-s\tdo single test");
 exit(0);
 }
 /* ----------------------------------------------------------- */
-int experiment(void)
+int experiment(char *fname)
 {
 int		foo;
 FloatImg	image, dest;

-fprintf(stderr, "--------- EXPERIMENT ------------\n");
+fprintf(stderr, "----- EXPERIMENT on '%s' -----\n", fname);

-foo = fimg_create_from_dump("mire.fimg", &image);
+foo = fimg_create_from_dump(fname, &image);
 if (foo) {
 	fprintf(stderr, "%s: err %d on create_from_dump\n",
 			__func__, foo);
@@ -177,8 +206,8 @@ if (foo) {

 foo = fimg_clone(&image, &dest, 0);

-foo = graylevel2popcolors(&image, &dest, 0);
-fprintf(stderr, "POP COLOR- -> %d\n", foo);
+foo = poke_sup_rb_g(&image, &dest);
+fprintf(stderr, "poke sup rb g --> %d\n", foo);

 fimg_export_picture(&dest, "foo.png", 0);

@@ -220,17 +249,25 @@ while ((opt = getopt(argc, argv, "hF:g:i:Lo:O:svx")) != -1) {
 	}

 #if DEBUG_LEVEL
-fprintf(stderr, "%s : argc = %d, optind = %d\n", argv[0], argc, optind);
+fprintf(stderr, ">>> %s : argc=%d, optind=%d\n", argv[0], argc, optind);
 #endif

+foo = essai_test_export_dir("bla bla");
+if (foo) {
+	fprintf(stderr, "err %d in essai_test_export_dir\n", foo);
+	exit(1);
+	}
+exit(0);
+
 foo = parse_filter_chain(STK, filterchain);
 if (foo) {
 	fprintf(stderr, "err %d in parse_filter_chain\n", foo);
 	exit(1);
 	}

+
 if (do_xper) {
-	experiment();
+	experiment(infile);
 	return 0;
 	}
 if (do_single) {
--- a/Fonderie/utilfuncs.c
+++ b/Fonderie/utilfuncs.c
@@ -0,0 +1,53 @@
+/*
+ *		utilfuncs.c
+ *
+ * new Sat Nov  9 22:15:15 UTC 2024
+ */
+
+#include  <stdio.h>
+#include  <unistd.h>
+#include  <sys/types.h>
+#include  <sys/stat.h>
+
+#include  "utilfuncs.h"
+
+extern int verbosity;
+
+/* -------------------------------------------------------------- */
+int check_if_export_dir_is_valid(char *path, int action)
+{
+int		foo;
+struct stat	statbuf;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s', %d )\n", __func__, path, action);
+#endif
+
+foo = stat(path, &statbuf);
+if (foo) {
+	if (verbosity) perror(path);
+	return 0;
+	}
+
+#if DEBUG_LEVEL
+fprintf(stderr, "    mode 0x%x\n", statbuf.st_mode);
+#endif
+if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+	if (verbosity) fprintf(stderr, "%s: Not a directory\n", path);
+	return 0;
+	}
+
+/* OK, c'est un repertoire, mais peut-on écrire dedans ? */
+foo = access(path, W_OK);
+#if DEBUG_LEVEL
+fprintf(stderr, "    access '%s' = %d\n", path, foo);
+#endif
+if (0 != foo) {
+	if (verbosity) fprintf(stderr, "%s: can't write\n", path);
+	return 0;
+	}
+
+return 1;		/* export dir is OK */
+}
+/* -------------------------------------------------------------- */
+
--- a/Fonderie/utilfuncs.h
+++ b/Fonderie/utilfuncs.h
@@ -0,0 +1,11 @@
+/*
+ *		utilfuncs.c
+ *
+ * new Sat Nov  9 22:15:49 UTC 2024
+ */
+
+/* -------------------------------------------------------------- */
+
+int check_if_export_dir_is_valid(char *path, int action);
+
+/* -------------------------------------------------------------- */
--- a/README.md
+++ b/README.md
@@ -7,7 +7,6 @@ voire même des [films flous](Fonderie/).

 ![horloge floue](http://la.buvette.org/photos/cumul/horloge.png "horloge floue")

-
 Il y a une [description](http://la.buvette.org/photos/cumul/) bien plus 
 pas trop longue pour les curieux, et un début de
 [documentation](http://la.buvette.org/photos/cumul/the_floatimg_hack.pdf)
@@ -22,7 +21,20 @@ Par ailleurs, d'autres expérimentations sont
 sur le traitement et l'assemblage de ces images floues dans le but de faire
 des films flous. 

-*En avant vers l'infini, et au-delà...*
+## *Show us the code !*
+
+Il y a plusieurs répertoires contenant le code source, en voici
+la liste :
+
+  * [lib](lib/README.md) : le noyau du système, fonctions de base.
+  * [funcs](funcs/README.md) : fonctions de support : export, traitement
+    filtrage, effets...
+  * [tools](tools/README.md) : utilitaires divers, outils de debug et gadgets.
+  * [v4l2](v4l2/README.md): gestion des webcams sous Linux.
+  * [experiment](experiment/README.md) : fonctions en chantier, qui migreront
+    un jour dans d'autres catégories.
+  * [contrib](contrib/README.md) : des choses peu ou pas maintenues.
+

 ## Dépendances

@@ -37,16 +49,15 @@ apt  install  liblo-dev
 apt  install  libv4l2-dev
 apt  install  libcfitsio-dev
 apt  install  libnetpbm-dev
+apt  install  libncurses-dev
 ```
-
 Bon, OK, je suis en train de changer de machine, et ça serait vraiment
 cool d'avoir juste une ligne à c'n'p, donc voila :

 ```
 apt install  libtiff-dev libpnglite-dev  liblo-dev  libv4l2-dev \
-             libcfitsio-dev libnetpbm-dev
+             libcfitsio-dev libnetpbm-dev libncurses-dev
 ```
-
 Il est probable que j'en oublie.
 Et ya Debian qui change des trucs, alors, ça marche plus, du
 genre que c'est la deuxième fois que ça m'arrive.
@@ -63,9 +74,9 @@ coté de pkg-config.

 Certains outils externes sont aussi utiles :

- gnuplot
- ImageMagick
- LaTeX
+- gnuplot, pour analyser des données,
+- ImageMagick, parce que Brunus aime ça,
+- LaTeX, pour la (trop maigre) documentation.

 ## Documentation

@@ -73,4 +84,10 @@ Encore trop légère, mais déja [présente](doc/).
 C'est à vous de compiler le
 [PDF](http://la.buvette.org/photos/cumul/the_floatimg_hack.pdf)

+## TODO
+
+https://berthub.eu/articles/posts/always-do-this-floating-point/
+
+## Conclusion
+
 *Your mileage may vary...*
--- a/build.sh
+++ b/build.sh
@@ -1,5 +1,7 @@
 #!/bin/bash

+set -e ; set -u
+
 # ------------------------------------------------------------------

 function build
--- a/doc/the_floatimg_hack.tex
+++ b/doc/the_floatimg_hack.tex
@@ -27,7 +27,8 @@
 \usepackage[verbose]{layout}
 \usepackage{ulem}

-\setlength \parskip {0.35em}
+\setlength \parskip {0.18em}
+\setcounter{tocdepth}{2}        	% XXX à regarder un de ces jours ?

 \makeatletter
 % explication de ce truc ?
@@ -53,9 +54,9 @@

 \section*{Une image flottante ?}

+\vspace{2em}
 \textsl{Mais de quoi parle-t-on exactement ?}
-
-% XXX XXX XXX\vspace{1em}
+\vspace{2em}

 Traditionnellement, les valeurs des pixels dans les images
 informatiques sont mémorisées sur 8 bits, un octet\index{octet},
@@ -79,7 +80,12 @@ IRC de \textsl{libera.chat}.

 \textbf{Attention !} ce document commence par une bonne rafale
 de technique parfois \textsl{hardue}\footnote{hard + ardue = private
-joke Usenet}, avec des pointeurs dedans.
+joke Usenet}, avec des pointeurs dedans, mais vous êtes déja
+au courant.
+Le pointeur, c'est bien, c'est comme le doigt sur les écrans
+de zombiephones, ça sert juste à dire «~C'est là !~», c'est
+donc gravement utile, mais parfois, le doigt glisse.
+Et là, tout peut arriver.
 Vous avez parfaitement le droit de sauter directement à
 la page \pageref{outils} pour quelque chose de plus concret.

@@ -104,7 +110,8 @@ numériques quand certains ont songé à passer du flou mental à la grille
 physique.

 Les détails techniques sur cette représentation sont en page
-\pageref{FloatImg desc}, avec des pointeurs dedans.
+\pageref{FloatImg desc}, avec des pointeurs et des
+tableaux dedans.
 Ah, les pointeurs, la pire chose du monde, mais pourquoi s'en passer\dots

 \subsubsection*{quelques rappels de comment on acquiert et numérise une image}
@@ -138,6 +145,7 @@ la glisser dans le capitalisme de surveillance.

 \setlength \parskip {0em}

+\pagebreak
 \tableofcontents
 \pagebreak
 \setlength \parskip {0.40em}
@@ -150,8 +158,10 @@ la glisser dans le capitalisme de surveillance.

 Pour le moment, seule la quête de l'empirisme absolu a été
 visée. Les justifications mathématiques attendront le retour
-du schmod777. Ceci dit, rien ne nous empêche d'aller consulter
-Wikipedia~:
+de monsieur Schmod777.
+Ceci dit, rien ne nous empêche d'aller consulter
+Wikipedia, afin de mieux connaitre ces nombres flottants
+que nous allons utiliser~:

 \begin{quotation}
 An IEEE 754 32-bit base-2 floating-point variable has
@@ -166,10 +176,11 @@ officially referred to as binary32; it was called single in
 IEEE 754-1985.
 \end{quotation}

-Ce qui nous conduit à estimer qu'il est possible de cumuler environ
-quelques milliers d'images standard à 256 niveaux, sans trop avoir
-à se soucier des éventuelles pertes de précision. Mais ça demande
-à être confirmé par des esprits supérieurs.
+% XXX
+% Ce qui nous conduit à estimer qu'il est possible de cumuler environ
+% quelques milliers d'images standard à 256 niveaux, sans trop avoir
+% à se soucier des éventuelles pertes de précision. Mais ça demande
+% à être confirmé par des esprits supérieurs.

 https://dl.acm.org/doi/pdf/10.1145/103162.103163

@@ -180,6 +191,12 @@ la fourbitude des calculs en virgule flottante avec les ordinateurs.
 Moi-même compris. Il est évident qu'une étude théorique doit être
 effectuée afin d'éviter les potentiels inconvénients.

+Ceci dit, le standard \textsl{ieee754}\index{ieee754} nous indique qu'il
+y a 23 bits pour la mantisse, ce qui nous propose déja
+plus de huit millions de valeurs possibles.
+Considérons un cas typique~:
+le cumul de $N$ images ayant un niveau maximum $Vm$.
+
 \subsection{Pixel négatif ?}

 Il est très difficle d'imaginer une lumière négative. Sauf peut-être
@@ -201,7 +218,7 @@ mais nous sommes tous là pour améliorer les choses, dans
 la mesure de nos moyens.
 Nous allons donc directement rentrer au cœur du problème,
 en écrivant quelques lignes de code montrant le fonctionnement
-général de la chose.
+général de la chose vu du coté de la machine.

 \subsection{L'idée}

@@ -226,8 +243,8 @@ en mémoire centrale, l'initialisation des valeurs de chaque pixel à 0.0
 (une valeur que certains associent au noir complet, et d'autres à une
 impossibilité quantique),
 et pour conclure, l'enregistrement de cette image dans un
-fichier\footnote{Au format
-ésotérique, mais très véloce.} binaire.
+fichier\footnote{Au format ésotérique, mais très véloce.}
+binaire.

 \begin{lstlisting}
 memset(fimg, 0, sizeof(FloatImg));
@@ -244,7 +261,6 @@ if (foo) {
        }
 \end{lstlisting}

-
 Une fois ce code enrobé dans un \texttt{main()}, compilé puis exécuté,
 nous pouvons entrevoir, grâce au logiciel
 \texttt{fimgstats} (décrit en page \pageref{fimgstats}),
@@ -283,7 +299,8 @@ une distribution Debian\index{Debian} récente (amd64 et x86),
 mais ça marche quasiment pareil avec Fedora\index{Fedora} 64,
 et
 probablement Raspbian\index{Raspbian}, modulo les éventuels
-soucis de boutisme.
+soucis de boutisme que j'ai absolument négligés de prendre
+en compte.
 \textit{Attention, ça va devenir un peu gore\dots}

 \subsection{Prérequis}
@@ -459,17 +476,18 @@ toucher. Les types d'images actuellement gérés sont les trois grands
 classiques : niveau de gris, rouge-vert-bleu et rgb avec un canal alpha, 
 et expliquées quelques lignes plus haut.

+XXX\index{XXX} raconter fimg\_clone
+
 Comme vous allez le voir plus loin, il y a plein de fonctions qui
 prennent en argument deux images: la source et la destination.
 Dans la plupart des cas, ces deux images doivent être compatibles,
-c'est à dire même type et mêmes dimensions.
+c'est à dire de même type et de mêmes dimensions.

 \begin{lstlisting}
 /* return 0 if pictures are compatible */
 int fimg_images_not_compatible(FloatImg *a, FloatImg *b);
 \end{lstlisting}

-
 C'est bien beau d'être enfin une image résidente en mémoire centrale, mais
 pouvoir aussi exister à long terme en étant stocké dans la matrice
 est tout aussi pertinent.
@@ -510,18 +528,19 @@ Si la valeur retournée est différente de 0, c'est que quelque
 chose s'est probablement mal passé.
 Certains messages sont parfois  explicites. Mais parfois non.
 Quand aux valeurs retournées en cas d'erreur, c'est le désordre
-intégral.
+intégral\footnote{Un vrai désastre, même...}.

 % 	_________

 \subsection{Dessiner}

-Bon, vous avez une image latente, et vous souhaitez dessiner dessus
-(ou dedans ?) avec vos encres flottantes ?
-Il y a des fonctions pour ça, par exemple~:
+Bon, vous avez en mémoire centrale une image latente,
+et vous souhaitez dessiner dessus (ou dedans ?) avec vos encres flottantes ?
+Il y a actuellement deux fonctions pour ça, légèrement différentes~:

 \begin{lstlisting}
 int fimg_plot_rgb(FloatImg *head, int x, int y, float r, float g, float b);
+int fimg_put_rgb(FloatImg *head, int x, int y, float rgb[3]);
 \end{lstlisting}

 Les paramètres sont explicites, mais leur validité doit être
@@ -660,10 +679,11 @@ aux bonnes dimensions (échange W et H).

 D'un design très empirique, c'est certainement à revoir pour l'avenir.
 La force du \textsl{legacy} va-t-elle dominer le monde ?
-Il faudrait normaliser l'endianess et le packing dans les structs%
-\footnote{Directives du compilateur ?}, et surtout l'ajout
+Il faudrait normaliser l'endianess et le packing dans les
+structuress\footnote{Directives du compilateur ?}, et surtout l'ajout
 de données sur la prise de vue, du genre type de capteur, date et heure,
-réglages divers\dots
+réglages divers. Nous appelerons ça les metadonnées, et
+nous en parlons dans quelques pages.\dots

 \begin{lstlisting}
 typedef struct {
@@ -908,7 +928,8 @@ int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
 Comme dans la plupart des cas, la gestion des valeurs négatives
 de pixel est laissé au hasard, qui fait souvent du portnawak.
 Quoique, il doit bien exister
-quelques solutions de contournement : clamping ou shift ?
+quelques solutions de contournement :
+valeur absolue, clamping ou shiftup ?

 \textsl{To be continued\index{XXX}\dots}

@@ -921,8 +942,8 @@ le répertoire \texttt{funcs/}.
 Elle aura donc accès aux \textsl{internals}%
 \footnote{que je peux décider de changer n'importe quand}
 de \textsc{FloatImg},
-une chose qui est en principe interdit aux programmes
-\textsl{enduser}. Soyez prudents.
+une chose qui est en principe interdite aux programmes
+\textsl{enduser}. Soyez donc prudents.

 Cette fonction va faire quelque chose
 à partir d'une image source et d'une valeur, et écrire le
@@ -965,14 +986,17 @@ de fonctions prévues à cet effet, mais il fallait rester simple\dots
 % ===================================================================
 \section{Les outils}\label{outils}

-\textsf{3615mavie} : sur des projets comme celui-ci, qui travaillent
-in-fine sur des objets que l'on peut considérer comme « physiques »,
+\textsf{3615mavie} : pour des projets comme celui-ci, qui travaillent
+\textit{in-fine} sur des objets que l'on peut considérer
+comme « physiques »,
 il est important de passer à une utilisation
-normale\footnote{Il y a une vie en dehors de git.} et construire
-des trucs qui mettent en action le code primitif pour partir
-sur des bases saines.
+normale\footnote{Il y a une vie en dehors de git et des compilations.}
+et construire
+des briques de base qui mettent en action le code primitif pour
+partir sur des bases stables, documentées (ahem\dots), et
+directement utilisables.

-Ces machins ont en commun quelques options bien pratiques~:
+Ces cliwares\index{cliware} ont en commun quelques options bien pratiques~:
 \texttt{-h} pour avoir un résumé des options disponibles,
 \texttt{-v} qui augmente la puissance de bavardage, et
 \texttt{-K nn.nn} pour un paramètre flottant.
@@ -1211,7 +1235,8 @@ après la grande pandémie\dots

 Cet outil accumule\index{cumul} une quantité d'images flottantes
 (de même taille et de même type) afin d'obtenir
-un flou temporel de meilleure qualité. Aucune mise à l'échelle n'etant
+un flou temporel de meilleure qualité.
+Aucune mise à l'échelle n'etant
 effectuée, les pixels de sortie peuvent atteindre des valeurs
 considérables\footnote{Faut-il prévoir une gestion des \textsf{overflows} ?}

@@ -1396,7 +1421,7 @@ le premier pouvant salement brotcher une image, et le second capable de
 mélanger harmonieusement deux images, la balance est équilibrée.

 Il s'agit donc d'un petit programme écrit en Bash\index{bash}, un langage
-dont la connaissance est, pour moi, indispendable à qui veut faire des
+dont la connaissance est, pour moi, indispensable à qui veut faire des
 images kitchies\index{kitchy}. Mais ne vous inquiétez pas, c'est en
 fait assez simple à comprendre. Et comprendre, c'est apprendre.

@@ -1599,7 +1624,8 @@ des choses essentielles comme la liste des résolutions disponibles.

 Ajustement \textsl{Brightness Contrast Saturation Hue\dots}

-Probablement pilotable au joystick\index{joystick}.
+Probablement pilotable au joystick\index{joystick} et surtout
+par OSC (Open Sound Control).

 % ===================================================================
 \section{À l'extérieur}
@@ -1609,6 +1635,8 @@ il est souvent nécessaire de pouvoir communiquer facilement
 avec eux. Nous avons déja quelques possibilité d'exportation,
 mais passer par cette étape intermédiaire est parfois délicat
 à gérer dans un \textsl{pipedeprod} autrement bien huilé.
+De même, nos capacités d'importation sont vraiment trop
+réduites, Jpeg et PNG étant les deux priorités.

 \subsection{ImageMagick}\index{ImageMagick}

@@ -1625,10 +1653,12 @@ devez mettre ce bout de XML\index{XML} dans le fichier
 \end{lstlisting}

 C'est juste un hack rapide, qui ne fonctionne pas très bien avec
-d'autres commande de IM, comme identify, qui a tendance à
+d'autres commande de IM, comme \texttt{identify}\index{identify},
+qui a tendance à
 raconter un peu n'importe quoi, puisqu'elle se base sur le
 résultat de la conversion.
-Je compte donc sur le bouquin de \textsl{Brunus} pour avancer\dots
+Je compte donc sur le bouquin de \textsl{Brunus}\index{Brunus}
+pour avancer\dots

 \subsection{Gimp}\index{Gimp}

@@ -1662,7 +1692,7 @@ Bon courage pour toutes les explorer, voire même juste les comprendre.
 Il y a d'autres logiciels pour lesquels écrire une fonction d'importation
 serait bien~: \textsl{Geeqie}, un visualiseur d'image fort pratique, ou
 \textsl{Krita} qui semble avoir les faveurs de
-dessinateurs de talent\footnote{Oui, David, c'est à toi que je pense.}.
+dessinateurs de talent.
 Ce qui nous conduit à une question importante~: quels sont les logiciels 
 qui gèrent le chargement d'image par un système de
 \textsl{plugin}\index{plugin},
@@ -1682,7 +1712,8 @@ ces images. Mais ce n'est qu'une façon déguisée de faire du cumul.
 C'est à ce moment que nous changeons l'axe de vue du défi.

 Par ailleurs, il m'a semblé pertinent d'inclure dans le projet une
-foultitude d'effets spéciaux.
+foultitude d'effets spéciaux%
+\footnote{\textsl{aka} IBM\index{IBM} (image brotching module)}.
 Qui manquent cruellement de possibilités de paramétrage.
 Mais peuvent être enchainés dans ce que j'appelle des
 \textsl{filter-chains}~: ces effets seront appliqués dans
@@ -1782,8 +1813,9 @@ usage:

 Il n'y a pas de moyenne mobile, pas d'interpolation, mais un facteur de
 répétition qui permet de dupliquer $N$ fois une image dans le flux de
-sortie. Si vous globez \texttt{frames/????[02468]}, vous prenez
-une image sur deux, alors un facteur de répétition à $2$ conservera
+sortie. Si vous globez \texttt{rush/????[02468]}, vous prenez
+en compte une image sur deux de la séquence capturée,
+alors un facteur de répétition à $2$ conservera
 la 'vitesse' de la séquence, mais avec une petite saccade régulière
 de bon aloi \textit{:)}

@@ -1792,8 +1824,7 @@ de bon aloi \textit{:)}
 \subsection{Déviance dans le flou ?}

 Là, nous tombons dans de la \textsl{troiD}\index{3d} de haut niveau,
-avec plein de maths compliquées
-à l'intérieur.
+avec plein de maths compliquées à l'intérieur.
 Et surtout quelque chose qui n'est encore qu'une idée abstraite,
 mais il y aura du zbuffer\index{zbuffer} dedans.

@@ -1812,12 +1843,18 @@ et sans but précis. Je le \textit{runne} et je le \textit{re-runne}
 un gazillion de fois dans mon cerveau processique.
 Quel va être son facteur $O$ ? Je fais donc des essais.

+\subsection{movepixels}
+
+\subsection{muxplanes}
+
 % ===================================================================

 \section{Et pour la suite ?}

 En fait, je fait de la photo par la méthode du « cumul »\index{cumul}
-depuis plusieurs années. Une webcam\index{webcam},
+depuis plusieurs années, au début avec vgrabbj et convert,
+puis avec floatimg et ses satellites.
+Une webcam\index{webcam},
 un Linux\index{Linux}, et ça \textsl{juste marche}.
 Sauf que c'est quand même un peu galère à déplacer, il faut
 avoir un shell pour déclencher, c'est pas facile à utiliser
@@ -1826,8 +1863,9 @@ en mode portnawak\dots
 L'idée est donc de construire un appareil autonome, basé sur un Raspi et
 une webcam \textsc{usb}\index{USB}, pilotable par \textsc{lirc}\index{LIRC},
 alimenté par une (grosse) batterie et permettant d'aller
-faire des images au bord d'un lac ou dans la campagne de l'Ariège.
-Et, comme le dit la sagesse populaire : « fimg at 11 ».
+faire des images au bord d'un lac ou dans la campagne du Gers%
+\footnote{Aux Bourtoulots, par exemple.}.
+Et comme le dit la sagesse populaire : « fimg at 11 ».

 % -------------------------------------------------------------------

--- a/essai.c
+++ b/essai.c
@@ -18,6 +18,8 @@ int		verbosity;
 void fait_un_dessin(FloatImg *dessin)
 {

+// fprintf(stderr, "je dessine dans %p\n", dessin);
+
 fimg_draw_something(dessin);

 }
@@ -26,6 +28,7 @@ void help(void)
 {
 puts("Options :");
 puts("\t-d WxH\timage size");
+puts("\t-v\tincrease verbosity");
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@@ -57,7 +60,7 @@ fimg_drand48(&fimgB, 100.0);
 foo = fimg_dump_to_file(&fimgB, "B.fimg", 0);

 fimg_timer_set(0);
-#define NBP 500
+#define NBP 5
 for (foo=0; foo<NBP; foo++) {
 	if (verbosity) {
 		printf("%5d     / %5d\n", foo, NBP);
@@ -67,9 +70,9 @@ for (foo=0; foo<NBP; foo++) {
 	// fimg_mul(&fimgA, &fimgB, &fimgA);
 	}
 tb = fimg_timer_get(0);
-fprintf(stderr, "%s = %f seconds\n", __func__, tb);
-foo = fimg_save_as_pnm(&fimgA, "drand48.pnm", 0);
-foo = fimg_dump_to_file(&fimgA, "drand48.fimg", 0);
+fprintf(stderr, "%s = %.2f seconds, %.2f s/p\n", __func__, tb, tb/(double)NBP);
+foo = fimg_save_as_pnm(&fimgA, "out.pnm", 0);
+foo = fimg_dump_to_file(&fimgA, "out.fimg", 0);

 fimg_destroy(&fimgA);
 fimg_destroy(&fimgB);
--- a/experiment/Makefile
+++ b/experiment/Makefile
@@ -7,16 +7,13 @@ COPT = -Wall -Wextra -fpic -g -DDEBUG_LEVEL=0 -lm
 DEPS = ../floatimg.h  ../libfloatimg.a Makefile
 LIBS = ../libfloatimg.a -ltiff -lpnglite -lcfitsio -lm

-all:	assemblage extracteur muxplanes movepixels mnt
+all:	assemblage muxplanes movepixels mnt

 # ---------------------------------------------------------

 assemblage:	assemblage.c ${DEPS} 
 	gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@

-extracteur:	extracteur.c ${DEPS}
-	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
-
 muxplanes:	muxplanes.c ${DEPS}
 	gcc $(COPT) $<   ${LIBS} -o $@

@@ -30,7 +27,7 @@ fimg2obj:	fimg2obj.c $(DEPS)
 	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@

 # ---------------------------------------------------------
-#			CACHE ENGINE
+#			CACHE ENGINE (wip)

 cachengn.o:	cachengn.c cachengn.h Makefile
 	gcc $(COPT) -c $< 
--- a/experiment/README.md
+++ b/experiment/README.md
@@ -1,7 +1,7 @@
-# EXPÉRIMENTATIONS ÀLC
+# Expérimentations ÀLC

 Attention, tout ce qui se trouve dans ce répertoire ne sont que des
-essais. Certains aboutissent, et sont migrés vers `funcs/` ou
+essais. Certains aboutissent, et sont migrés vers `lib/`, `funcs/` ou
 `tools/`, d'autre échouent et restent trainer dans le coin en attente
 du retour de l'inspiration.

@@ -11,11 +11,19 @@ d'en faire une copie personnelle...

 ## MNT

-Modèles numériques de terrain. Rien ne marche.
+Modèles numériques de terrain. Rien ne marche. Plein de maths.
+Un [code](mnt.c) complexe.

 ## fimg2obj

-Création d'un fichier .OBG (de Wavefront) à partir d'une image
+Création d'un fichier .OBJ (de Wavefront) à partir d'une image
 flottante afin d'avoir des vues en 3d pertinentes, bien qu'assez
 futiles.

+## système de cache
+
+`new: Mon Jul 17 12:49:20 UTC 2023`
+
+En cours : définition d'à peu-près tout ce qu'il reste à faire
+pour avoir quelque chose qui fonctionne.
+Plus d'information dans le [.h](cachengn.h).
--- a/experiment/assemblage.c
+++ b/experiment/assemblage.c
@@ -51,7 +51,6 @@ if (foo) {
 	return -1;
 	}

-
 foo =  fimg_export_picture(&grande, outname, 0);
 if (foo) {
 	fprintf(stderr, "%s: error %d export '%s'\n", __func__,
--- a/experiment/cachengn.c
+++ b/experiment/cachengn.c
@@ -3,23 +3,143 @@
 */

 #include  <stdio.h>
+#include  <unistd.h>
+#include  <sys/time.h>
+#include  <stdlib.h>
+#include  <string.h>

+#include  "../floatimg.h"
 #include  "cachengn.h"

+extern int		verbosity;
+
+static int		nombre_slots = -1;
+static int		index_slot   = -1;
+static FimgCacheEntry	*le_cache    = NULL;
+
 /* ------------------------------------------------------------ */

 void cachengn_print_version(int k)
 {

-printf("this is the version ZERO !!!\n");
+printf("\t!!! this is the version ZERO !!!\n");

+fprintf(stderr, "sizeof cache entry: %ld\n", sizeof(FimgCacheEntry));
+
+if (k) fimg_print_version(0);
 }
-
 /* ------------------------------------------------------------ */
-int init_empty_cache(int iw, int ih, int szc, int nbre)
+/*
+ *
+ */
+int init_empty_cache(int iw, int ih, int szc, int wtfparam)
 {
-return -1;
+int		idx;
+
+fprintf(stderr, ">>> %s ( %d %d %d   %d )\n", __func__,
+			iw, ih,  szc, wtfparam);
+
+/* MOLLYGUARD : don't init TWICE, please */
+if (NULL != le_cache) {
+	fprintf(stderr, "%s: there is a cache at %p\n", __func__,
+						le_cache);
+	return -2;
+	}
+
+/* allocate an prepare memory */
+if ( NULL==(le_cache=calloc(szc, sizeof(FimgCacheEntry))) ) {
+	fprintf(stderr, "%s: no memory, sorry...\n", __func__);
+	return -3;
+	}
+fprintf(stderr, "    slot array at %p\n", le_cache);
+for (idx=0; idx<szc; idx++) {
+	le_cache[idx].flags = 0xF0;
+	le_cache[idx].index = idx;
+	}
+
+/* update private cache metadata */
+nombre_slots = szc;
+
+return 0;
 }

 /* ------------------------------------------------------------ */
+/*
+ *
+ */
+FloatImg *give_me_thiz_picz(char *fname, int notused)
+{
+int			idx, foo, freeslot;
+FloatImg		img;
+char			*nptr;
+
+fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
+
+/* please add molly guard ! */
+
+if (notused)
+	fprintf(stderr, "in %s, notused was %d\n", __func__, notused);
+
+/* is the floatimg already in the cahce ? */
+for (idx=0; idx<nombre_slots; idx++) {
+	nptr = le_cache[idx].filename;
+	if (NULL!=nptr && (! strcmp(fname, nptr))) {
+		fprintf(stderr, "found '%s' at %d\n", nptr, idx);
+		return le_cache[idx].image;
+		}
+	}
+
+/* we not have this picture in our cache, so we need a free
+   slot for it */
+freeslot = -1;
+for (idx=0; idx<nombre_slots; idx++) {
+	if (NULL==le_cache[idx].image) {
+		freeslot = idx;
+		break;
+		}
+	}
+fprintf(stderr, "freeslot = %d\n", freeslot);
+
+/* check if we can read this file */
+foo = access(fname, R_OK);			/* XXX */
+if (foo) {
+	perror("give_me_thiz_picz");
+	return NULL;
+	}
+fprintf(stderr, "file '%s' is readble\n", fname);
+
+/* try to load the requested file */
+foo = fimg_create_from_dump(fname, &img);
+if (foo) {
+	fprintf(stderr, "oups on %s\n", fname);
+	return NULL;
+	}
+/* OK, we have all the pixels in core memory */
+
+return NULL;
+}
+/* ------------------------------------------------------------ */
+/*
+ *
+ */
+int liste_le_cache(unsigned int flags)
+{
+int		idx;
+
+fprintf(stderr, ">>> %s ( Ox%X )\n", __func__, flags);
+
+/* please add molly guard here */
+
+fprintf(stderr, "cache at %p : %d slots, idx = %d\n",
+				le_cache, nombre_slots, index_slot);
+
+for (idx=0; idx<nombre_slots; idx++) {
+	fprintf(stderr, "%5d    ", idx);
+	fprintf(stderr, "0x%02x ", le_cache[idx].flags);
+	fprintf(stderr, "%p     ", le_cache[idx].image);
+	fprintf(stderr, "%s\n",    le_cache[idx].filename);
+	}
+
+return 0;
+}
 /* ------------------------------------------------------------ */
--- a/experiment/cachengn.h
+++ b/experiment/cachengn.h
@@ -4,4 +4,26 @@

 void cachengn_print_version(int k);

+typedef struct {
+	int		flags;
+	char		*filename;
+	FloatImg	*image;
+	int		index;
+	} FimgCacheEntry;
+
+
+/*
+ *		parameters:
+ *	- iw, ik   : image size
+ *	- szc      : number of slots
+ *	- nbre     : WTF isthat?
+ */
 int init_empty_cache(int iw, int ih, int szc, int nbre);
+
+
+/* /!\ the floatimg returned must be view as readonly */
+FloatImg *give_me_thiz_picz(char *fname, int notused);
+
+
+/* utilities functions */
+int liste_le_cache(unsigned int flags);
--- a/experiment/extracteur.c
+++ b/experiment/extracteur.c
@@ -1,132 +0,0 @@
-/*
- *		another ugly experiment
- */
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <unistd.h>
-#include  <stdint.h>
-
-#include  "../floatimg.h"
-
-int		verbosity;
-
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-int essai_extraction(FloatImg *in, FloatImg *out, FimgArea51 *rect)
-{
-int		foo;
-int		xs, ys, xd, yd;
-int		count;
-float		rgb[3];
-
-if (verbosity) {
-	fimg_describe(in,  "source");
-	fimg_describe(out, "destination");
-	print_rectangle((char *)__func__, rect);
-	}
-
-count = 0;
-for (yd=0; yd<rect->h; yd++) {
-	ys = yd + rect->y;
-	if ((ys<0) || (ys>=in->height)) continue;
-	for (xd=0; xd<rect->w; xd++) {
-		xs = xd + rect->x;
-		if ((xs<0) || (xs>=in->width)) continue;
-		fimg_get_rgb(in,  xs, ys, rgb);
-		fimg_put_rgb(out, xd, yd, rgb);
-		count++;
-		}
-	}
-
-// fprintf(stderr, "%s: %d pix moved\n", __func__, count);
-
-return 0;
-}
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-void help(int k)
-{
-puts("Usage:\n\textracteur in.fimg w,h,x,y out.???");
-}
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-
-int main(int argc, char *argv[])
-{
-int		foo, opt;
-FloatImg	src, dst;
-FimgArea51	zone;
-char		*infile  = "foo.fimg";
-char		*outfile = "out.fimg";
-
-verbosity = 0;
-
-#if 0
-for (foo=0; foo<argc; foo++) {
-	fprintf(stderr, "%9d   %s\n", foo, argv[foo]);
-	}
-#endif
-
-fprintf(stderr, "*** Extracteur  %s %s\n", __DATE__, __TIME__);
-
-while ((opt = getopt(argc, argv, "hv")) != -1) {
-	switch(opt) {
-		case 'h':	help(0), exit(0);	break;
-		case 'v':	verbosity++;		break;
-		default:				break;
-		}
-	}
-
-if (3 != argc-optind) {
-	fprintf(stderr, "---- %s errcli c=%d %d ----\n", argv[0],
-					argc, argc-optind);
-	help(1);
-	exit(1);
-	}
-
-if (verbosity) {
-	fprintf(stderr, "*** %s\n\t%s %s\n", argv[0], __DATE__, __TIME__);
-	fimg_print_version(1);
-	}
-
-infile = argv[optind];	outfile = argv[optind+2];
-fprintf(stderr, "%s\n\t%s  -->  %s\n", argv[0], infile, outfile);
-
-foo = fimg_create_from_dump(infile, &src);
-if (foo) {
-	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
-					foo, infile);
-	exit(1);
-	}
-
-if (4 != parse_rectangle( argv[optind+1], &zone, 0) ) {
-	fprintf(stderr, "%s: error in parsing of '%s'\n",
-					argv[0], argv[optind+1]);
-	exit(1);
-	}
-
-// zone.w = src.width / 2;		zone.h = src.height / 2;
-// zone.x = src.width / 4 ;	zone.y = src.height / 4;
-
-if (verbosity) print_rectangle(argv[0], &zone);
-
-foo = fimg_create(&dst, zone.w, zone.h,  FIMG_TYPE_RGB);
-if (foo) {
-	fprintf(stderr, "NO PICZ EPIC FAIL %d\n", foo);
-	exit(1);
-	}
-
-foo = fimg_extractor(&src, &dst, &zone);
-if (foo) {
-	fprintf(stderr, "EXTRACTOR EPIC FAIL %d\n", foo);
-	exit(1);
-	}
-
-foo = fimg_export_picture(&dst, outfile, 0);
-if (foo) {
-	fprintf(stderr, "export '%s' -> err %d\n", outfile, foo);
-	exit(1);
-	}
-
-return 0;
-}
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
--- a/experiment/mnt.c
+++ b/experiment/mnt.c
@@ -13,12 +13,34 @@

 int		verbosity;

+/* ------------------------------------------------------------------- */
+/* for debug purpose */
+int printf_histo_gray(char *fname, int histo[], int nbre)
+{
+FILE		*fp;
+int		idx; 
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p %d )\n", __func__,
+			fname, histo, nbre);
+#endif
+
+if (NULL == (fp = fopen(fname, "w"))) {
+	perror(fname);
+	exit(1);
+	}
+for (idx=0; idx<nbre; idx++) {
+	fprintf(fp, "%6d  %8d\n", idx, histo[idx]);
+	}
+fclose(fp);
+
+return -1;
+}
 /* ------------------------------------------------------------------- */
 /* for debug purpose */
 int calcul_histo_gray(FloatImg *img, char *fname, int nbslots, float *pmax)
 {
 int		offset, nbpix, ival;
-FILE		*fp;
 float		pixel, minp, maxp;
 int		*counts;

@@ -40,14 +62,14 @@ if (NULL == counts) {
 	}

 nbpix = img->width * img->height;
-minp = 1e10, maxp = -1e10;
+minp = 1e30, maxp = -1e30;

 for (offset=0; offset<nbpix; offset++) {
 	pixel = img->R[offset];
 	if (pixel < minp)	minp = pixel;
 	if (pixel > maxp)	maxp = pixel;
 	}
-fprintf(stderr, "    values =   %g  <  %g\n", minp, maxp);
+// fprintf(stderr, "    values =   %g  <  %g\n", minp, maxp);

 *pmax = maxp;		/* copy value for the caller */

@@ -59,14 +81,10 @@ for (offset=0; offset<nbpix; offset++) {
 	// fprintf(stderr, "%6d    %10.6f    %i\n", offset, pixel, ival);
 	}

-if (NULL == (fp = fopen(fname, "w"))) {
-	perror(fname);
-	exit(1);
+if (NULL != fname)
+	{
+	printf_histo_gray(fname, counts, nbslots);
 	}
-for (ival=0; ival<nbslots; ival++) {
-	fprintf(fp, "%6d  %8d\n", ival, counts[ival]);
-	}
-fclose(fp);

 /* garbage collect stuff */
 free(counts);
@@ -93,9 +111,11 @@ fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
 /*
 *	trying some preprocessor filters
 */
-//foo = fimg_lissage_2x2(src);
 foo = fimg_lissage_3x3(src);
-if (foo) fprintf(stderr, "    lissage -> %d\n", foo);
+if (foo) fprintf(stderr, "    lissage 1 -> %d\n", foo);
+foo = fimg_lissage_3x3(src);
+if (foo) fprintf(stderr, "    lissage 2 -> %d\n", foo);
+
 foo = fimg_killborders(src);
 if (foo) fprintf(stderr, "    killborder -> %d\n", foo);

@@ -110,6 +130,7 @@ if (foo) {
 	fprintf(stderr, "create tmp pic --> %d\n", foo);
 	return foo;
 	}
+
 /* calcul de la pente : a vérifier ! */
 for (y=0; y<(src->height-1); y++) {
 	for (x=0; x<(src->width-1); x++) {
@@ -129,11 +150,11 @@ for (y=0; y<(src->height-1); y++) {
 foo = calcul_histo_gray(&tmp, "histogramme.data", 499, &maxp);
 if (foo) fprintf(stderr, "<<< calcul histo -> %d\n", foo);

-
 minp = 1e10;
 seuil = 0.700 * maxp;
 fprintf(stderr, "    seuil = %f\n", seuil);

+/*		ésotérisme, quand tu nous tiens...		*/
 for (offset=0; offset<(src->width*src->height); offset++) {
 	pente = tmp.R[offset];
 	if (pente > seuil) {
@@ -144,12 +165,17 @@ for (offset=0; offset<(src->width*src->height); offset++) {
 // fprintf(stderr, "    minp = %f      maxp = %f\n", minp, maxp);

 /* recopie dans l'image destination avec translation hauteur */
+fimg_clear(dst);
 for (offset=0; offset<(src->width*src->height); offset++) {
 	pente = tmp.R[offset] - minp;
-	if (pente < 0.0)  pente = 0.0;
-	dst->R[offset] = pente;
-	dst->G[offset] = pente;
+	if (pente < 0.0) {
+		dst->R[offset] = -pente;
+		dst->G[offset] = -pente;
+		}
+	else	{
 		dst->B[offset] = pente;
+		dst->G[offset] = pente;
+		}
 	}

 foo = fimg_killborders(dst);
--- a/experiment/movepixels.c
+++ b/experiment/movepixels.c
@@ -65,12 +65,11 @@ for (yd=0; yd<pdst->height; yd++) {
 		fimg_get_rgb(pshift, xd, yd, disp);

 		xs = xd + ((disp[0]/dltr*MULT) - OFFS);
-		ys = yd + ((disp[2]/dltb*MULT) - OFFS);
+		ys = yd + ((disp[1]/dltb*MULT) - OFFS);

 		if ( xs<0 || xs>psrc->width 	||
 		     ys<0 || ys>psrc->height ) {
-			rgb[0] = maxv;			/* fucking bug XXX */
-			rgb[1] = rgb[2] = 0.0;
+			rgb[0] = rgb[1] = rgb[2] = 0.0;
 			outside++;
 			}
 		else {
@@ -79,7 +78,6 @@ for (yd=0; yd<pdst->height; yd++) {
 			}

 		fimg_put_rgb(pdst, xd, yd, rgb);
-
 		}

 	}
@@ -89,7 +87,10 @@ for (yd=0; yd<pdst->height; yd++) {
 return 0;
 }
 /* ------------------------------------------------------------------- */
-
+/*
+ *	High level operateur, taking care of opening/closing
+ *	files and doing memory management
+ */
 int move_the_pixels(char *infile, char *statfile, char *outfile, int k)
 {
 int		foo;
@@ -145,9 +146,10 @@ srcfile = argv[1];
 dstfile = argv[2];
 verbosity = 0;

-foo = move_the_pixels(srcfile, "cumul.fimg", dstfile, 3);
+/* XXX the static picture file MUST be selectable by the yuser ! */
+foo = move_the_pixels(srcfile, "reference.fimg", dstfile, 3);

-// fprintf(stderr, "move pixels %s -> %s = %d\n", srcfile, dstfile, foo);
+fprintf(stderr, "move pixels %s -> %s = %d\n", srcfile, dstfile, foo);

 return 0;
 }
--- a/experiment/muxplanes.c
+++ b/experiment/muxplanes.c
@@ -1,5 +1,5 @@
 /*
- *		another ugly experiment
+ *		another ugly experiment (please explain)
 */
 #include  <stdio.h>
 #include  <stdlib.h>
@@ -14,9 +14,8 @@ int		verbosity;
 /* --------------------------------------------------------------- */

 int triplane_muxer(FloatImg *sr, FloatImg *sg, FloatImg *sb,
-					FloatImg *dst, int flages)
+					FloatImg *dst)
 {
-int		foo;
 int		sz;

 if (FIMG_TYPE_RGB != dst->type) {
@@ -48,6 +47,10 @@ FloatImg	imr, img, imb, dest;

 fprintf(stderr, "muxing: %s %s %s -> %s\n", fr, fg, fb, dst);

+if (flags) {
+	fprintf(stderr, "%s: flag non 0 ?\n", __FILE__);
+	}
+
 foo = fimg_create_from_dump(fr, &imr);
 if (foo) {
 	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fr);
@@ -55,18 +58,18 @@ if (foo) {
 	}
 foo = fimg_create_from_dump(fg, &img);
 if (foo) {
-	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fr);
+	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fg);
 	return -1;
 	}
 foo = fimg_create_from_dump(fb, &imb);
 if (foo) {
-	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fr);
+	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fb);
 	return -1;
 	}

 fimg_clone(&imr, &dest, 0);

-foo = triplane_muxer(&imr, &img, &imb, &dest, 0);
+foo = triplane_muxer(&imr, &img, &imb, &dest);
 if (foo) {
 	fprintf(stderr, "%s: err %d\n", __func__, foo);
 	return foo;
--- a/experiment/remotegrab.c
+++ b/experiment/remotegrab.c
--- a/experiment/tcache.c
+++ b/experiment/tcache.c
@@ -3,24 +3,45 @@
 */

 #include  <stdio.h>
+#include  <sys/time.h>

+#include  "../floatimg.h"
 #include  "cachengn.h"

+int		verbosity;
+
 #define IMGW	320
 #define IMGH	240
-#define SIZE	20
+
+#define SIZE	5		// number of slots
 #define NBRI	1000

 /* ------------------------------------------------------------ */
 int main(int argc, char *argv[])
 {
 int		foo;
+FloatImg	*picz;
+char		*fname = "quux.fimg";

-fprintf(stderr, "Test of the cache engin - %s %s\n", __DATE__, __TIME__);
+fprintf(stderr, "\nTest of the cache engin - %s %s\n",
+					__DATE__, __TIME__);
 cachengn_print_version(1);

 foo = init_empty_cache(IMGW, IMGH, SIZE, NBRI);
-fprintf(stderr, "init_empty_cache --> %d\n", foo);
+fprintf(stderr, "    init_empty_cache --> %d\n", foo);
+
+foo = liste_le_cache((unsigned int)'U');
+fprintf(stderr, "    liste le cache --> %d\n", foo);
+
+picz = give_me_thiz_picz(fname, 0);
+if (NULL == picz) {
+	fprintf(stderr, "    error 'givemeapicz' on '%s'\n", fname);
+	}
+
+picz = give_me_thiz_picz(fname, 0);
+if (NULL == picz) {
+	fprintf(stderr, "    error 'givemeapicz' on '%s'\n", fname);
+	}

 return 0;
 }
--- a/floatimg.h
+++ b/floatimg.h
@@ -20,13 +20,40 @@
 *	https://git.tetalab.org/tTh/FloatImg
 */

-#define		FIMG_VERSION	(224)
+#define		FIMG_VERSION	(245)
 #define		RELEASE_NAME	("noname")
+#define		PATCH_LEVEL	("aaaa")
+

 /* XXX add a test for stdint.h / uint32_t XXX */
 #include  <stdint.h>
+
+
+/*
+ *		new 11 mars 2022, and a lot of iterations
+ *		around the concept of metadata for my work.
+ *
+ *	we MUST look at packing and endianess problems NOW
+ *	and we can think about a fixed size of this datablock
+ */
+#define MAGIC_MDATA	0xfe007007
+typedef struct {
+	uint32_t	magic;
+	uint32_t	padding;
+
+	struct timeval	timestamp;	// #include  <stdlib.h>
+	uint64_t	cpid;		// process id of the creator
+	int32_t		count;
+	float		fval;
+	char		idcam[32];
+	int32_t		origin;			// enum ?
+	uint32_t	reserved[8];
+	} FimgMetaData;
+
+
 /*
 *	in memory descriptor of a floating image
+ *	----------------------------------------
 */
 #define MAGIC_FIMG	0x00F11F00
 typedef struct {
@@ -37,6 +64,7 @@ typedef struct {
 	float		fval;
 	int		count;
 	float		*R, *G, *B, *A;
+	FimgMetaData	mdatas;			// added 20230912
 	int		reserved;
 	} FloatImg;

@@ -44,33 +72,13 @@ typedef struct {
 *	fimg file header (short version)
 */
 typedef struct {
-	char		magic[8];	// this is not an asciiz !
+	char		magic[8];	/* this is not an asciiz ! */
 	int32_t		w, h, t;
 	/*
 	 *  what about the packing ?
 	 */
 	} FimgFileHead;

-/*
- *		new 11 mars 2022, and a lot of iterations
- *		around the concept of metadata for my work.
- */
-typedef struct {
-	char		magic[8];	// this is not an asciiz !
-	struct timeval	timestamp;
-	uint64_t	cpid;		// process id of the creator
-	int32_t		count;
-	float		fval;
-	char		idcam[32];
-	int32_t		origin;			// enum ?
-	uint32_t	reserved[8];
-
-	} FimgMetaData;
-/*
- *	we MUST look at packing and endianess problems NOW
- *	and we can think about a fised size of this datablock
- */
-

 #define MAGIC_AREA51	0xA5EA0051
 typedef struct {
@@ -181,9 +189,9 @@ int fimg_crump_hard(FloatImg *src, FloatImg *dst, float kval, int notused);
 /*	 module sfx4.c			*/
 int fimg_sfx_triplemul(FloatImg *s, FloatImg *d, int notused);
 int fimg_split_level(FloatImg *src, FloatImg *dst, int notused);
+int fimg_make_triptyq(FloatImg *src, FloatImg *dst, int notused);

 /*	funcs/rotate.c module		*/
-/*	#coronamaison			*/
 int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused);

 int fimg_killrgb_v(FloatImg *src, FloatImg *dst, int k);
@@ -223,6 +231,7 @@ int fimg_falsecolors_0(FloatImg *src, FloatImg *dst, int k, float valf);
 /*	funcs/fmorpho.c			*/
 int fimg_filtre_morpho_0(FloatImg *sfimg, FloatImg *dfimg, int index);

+int fimg_auto_thermique(FloatImg *src, FloatImg *dst, int k);

 /*	--> funcs/plasmas.c		*/
 int fimg_prototype_plasma(FloatImg *img, double time, int type);
@@ -251,7 +260,6 @@ int fimg_halfsize_1(FloatImg *src, FloatImg *dst, int notused);
 int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect);
 int fimg_mirror(FloatImg *src, FloatImg *dst, int notused);

-
 int fimg_incrustator_0(FloatImg *psrc, FloatImg *pdst,
 				int xpos, int ypos, int flags);

@@ -260,7 +268,7 @@ int fimg_displacement_0(FloatImg *psrc, FloatImg *pdst, int flags);
 /*	module funcs/rampes.c		*/
 int fimg_hdeg_a(FloatImg *img, double dcoef);
 int fimg_vdeg_a(FloatImg *img, double dcoef);
-int fimg_do_stripes(FloatImg *img, int mode);
+int fimg_do_stripes(FloatImg *img, float fmax, int mode);

 /*	FIMG native file module		*/
 int   fimg_fileinfos(char *fname, int *datas);
@@ -275,6 +283,9 @@ int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused);
 int fimg_default_metadata(FimgMetaData *pmd, int bla);
 int fimg_get_metadata_from_file(char *fname, FimgMetaData *pmd);

+/*
+ *	FITS, an image fileformat for astronomy
+ */
 int fimg_save_R_as_fits(FloatImg *src, char *outname, int flags);
 int fimg_save_G_as_fits(FloatImg *src, char *outname, int flags);
 int fimg_save_B_as_fits(FloatImg *src, char *outname, int flags);
@@ -283,7 +294,6 @@ int fimg_save_plane_as_fits(FloatImg *src, char *oname, char plane, int flags);
 int fimg_write_as_tiff(FloatImg *src, char *fname, int flags);
 int fimg_save_as_exr(FloatImg *src, char *outname, int flags);

-
 /*	mathematics operations 				*/
 float fimg_get_plane_maxvalue(FloatImg *psrc, char plane);
 float fimg_get_maxvalue(FloatImg *head);
@@ -299,6 +309,8 @@ void  fimg_drand48(FloatImg *fi, float kmul);
 long   fimg_count_negativ(FloatImg *fi);
 long   fimg_clamp_negativ(FloatImg *fi);

+int fimg_max_of_max(FloatImg *img, float maxes[3]);
+
 /*	various funcs modules		*/
 int   fimg_load_from_png(char *filename, FloatImg *fimg);
 int   fimg_create_from_png(char *filename, FloatImg *fimg);
--- a/funcs/.gitignore
+++ b/funcs/.gitignore
@@ -0,0 +1,10 @@
+
+tpnm
+t
+*.o
+*.png
+*.gif
+*.fits
+*.tiff
+
+
--- a/funcs/Makefile
+++ b/funcs/Makefile
@@ -9,7 +9,7 @@ DEPS = ../floatimg.h Makefile
 OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o	\
 	fimg-libpnm.o rampes.o rectangle.o			\
 	sfx0.o sfx1.o sfx2.o sfx3.o sfx4.o			\
-	falsecolors.o	fmorpho.o				\
+	falsecolors.o thermocolor.o fmorpho.o				\
 	geometry.o rotate.o fimg-openexr.o			\
 	equalize.o fimg-fits.o saturation.o histogram.o		\
 	fimg-dicom.o						\
@@ -19,6 +19,11 @@ OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o	\

 #---------------------------------------------------------------

+all:	t
+
+tests.o:	tests.c tests.h $(DEPS)
+	gcc $(COPT) -I/usr/include/netpbm -c $<
+
 t:	t.c $(DEPS) ../libfloatimg.a tests.o
 	gcc $(COPT) $<						\
 		tests.o						\
@@ -28,8 +33,9 @@ t:	t.c $(DEPS) ../libfloatimg.a tests.o
 		-ltiff						\
 		-lz -lm -o $@

-tests.o:	tests.c tests.h $(DEPS)
-	gcc $(COPT) -I/usr/include/netpbm -c $<
+tpnm:		tpnm.c Makefile fimg-libpnm.o
+	gcc $(COPT) -I/usr/include/netpbm 			\
+		fimg-libpnm.o -lnetpbm  $< -o $@

 #---------------------------------------------------------------
 #	upper-level functions
@@ -144,6 +150,8 @@ exporter.o:		exporter.c $(DEPS)
 falsecolors.o:		falsecolors.c $(DEPS)
 	gcc $(COPT) -c $<

+thermocolor.o:		thermocolor.c $(DEPS)
+	gcc $(COPT) -c $<

 hsv.o:		hsv.c $(DEPS)
 	gcc $(COPT) -c $<
--- a/funcs/README.md
+++ b/funcs/README.md
@@ -2,34 +2,43 @@

 Plein de fonctions qu'il serait bon de documenter :)

-## PNG
-
-__Attention__ : la bibliothèque `pnglite`actuellement utilisée pour lire
-les fichiers PNG n'accepte que **certains** types de fichiers.
-Et en particulier, elle brotche sur ceux produits par ImageMagick !
-
-## FITS
-
-Un Format de fichier utilisé en astronomie. 
-
-https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/c_user/node1.html
-
-## DICOM
-
-https://en.wikipedia.org/wiki/DICOM et ça semble bien compliqué :(

 ## Contours

 Détecter des contours est une activité respectable. Mais difficile.
+Une recherche dans la littérature s'impose.

 ## Exporter

-Une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
-une image en fonction de l'extension du nom de fichier.
+`fimg_exporter` est une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
+une image en fonction de l'extension du nom de fichier fourni.
+
+### PNG
+
+__Attention__ : la bibliothèque `pnglite` actuellement utilisée pour lire
+les fichiers PNG n'accepte que certains types de fichiers.
+Et en particulier, elle brotche sur ceux produits par ImageMagick !
+
+### FITS
+
+Ce [format de fichier](https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/c_user/node1.html)
+est utilisé en astronomie.
+Son support est actuellement minimaliste.
+
+
+### DICOM
+
+https://en.wikipedia.org/wiki/DICOM et ça semble bien compliqué,
+donc ça reste pour le moment au stade de vague projet :(

 ## Sfx

-Effets spéciaux divers.
+Effets spéciaux divers. Ils sont répartis dans plusieurs fichiers
+(`sfx[0-4].c`) sans raison de classement apparente.
+
+Certains peuvent être directement utilisés
+avec l'outil [../tools/fimgfx.c](fimgfx).
+Leur paramétrage est trop sommaire.

 La fonction `fimg_pixelize_h_rnd` est issue d'une idée qui m'est venue
 dans la roulotte de TerreBlanque. Elle a besoin de recherches sur la
@@ -38,3 +47,7 @@ dynamique temporelle, et d'une FSM à trois états.
 ## Dithering

 Work in progress...
+
+Une difficulté dans ce domaine, c'est la *floattitude* des pixels,
+sur laquelle il est difficile d'appliquer des operations binaires,
+comme le XOR.
--- a/funcs/displacement.c
+++ b/funcs/displacement.c
@@ -46,7 +46,7 @@ if (foo) {
 if (verbosity) {
 	fimg_print_minmax(minmax, (char *)__func__);
 	}
-dltr = minmax[1] - minmax[0];
+// dltr = minmax[1] - minmax[0];
 dltg = minmax[3] - minmax[2];
 dltb = minmax[5] - minmax[4];

--- a/funcs/dithering.c
+++ b/funcs/dithering.c
@@ -23,6 +23,11 @@ fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, psrc, pdst, flags);

 if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }

+if (fimg_images_not_compatible(psrc, pdst)) {
+	fprintf(stderr, "%s: shit happen\n", __func__);
+	return -2;
+	}
+
 for (y=0; y<psrc->height; y++) {

 	for (x=0; x<psrc->width; x++)
--- a/funcs/filtrage.c
+++ b/funcs/filtrage.c
@@ -29,12 +29,12 @@ fprintf(stderr, "%8.3f   %8.3f   %8.3f\n", M[6], M[7], M[8]);

 sum = 0.0;
 for (idx=0; idx<9; idx++)	sum += M[idx];
-fprintf(stderr, "     sum  %8.3f\n", sum);
-fprintf(stderr, "    mult  %8.3f\n", filtr->mult);
-fprintf(stderr, "  offset  %8.3f\n", filtr->offset);
+fprintf(stderr, "        sum:  %8.3f\n", sum);
+fprintf(stderr, "       mult:  %8.3f\n", filtr->mult);
+fprintf(stderr, "     offset:  %8.3f\n", filtr->offset);

 value = (sum * filtr->mult) + filtr->offset;
-fprintf(stderr, "   value  %8.3f   ???\n", value);
+fprintf(stderr, "      value:  %8.3f\n", value);

 return 0;
 }
@@ -59,12 +59,12 @@ if (dst->type != FIMG_TYPE_RGB) {
 	return -99;
 	}
 if (fimg_images_not_compatible(src, dst)) {
-	fprintf(stderr, "%s: src & dst not comatibles\n", __func__);
+	fprintf(stderr, "%s: src & dst not compatibles\n", __func__);
 	return -98;
 	}

 if (verbosity > 1) {
-	fimg_show_filter("essai", filtr);
+	fimg_show_filter((char *)__func__, filtr);
 	}

 /*	aliasing some vars for cleaner code */
@@ -73,9 +73,7 @@ w = src->width;	h = src->height;
 M = filtr->matrix;

 for (y=1; y < h-1; y++) {
-
 	for (x=1; x < w-1; x++) {
-
 		of = x + (y * w);

 	dval =	M[0] * pr[of-(w+1)]	+
@@ -142,9 +140,7 @@ if (img->type != FIMG_TYPE_RGB) {
 pr = img->R;	pg = img->G;	pb = img->B;

 for (y=1; y < img->height-1; y++) {
-
 	for (x=1; x < img->width-1; x++) {
-
 		offset = x + (y * img->width);

 	cr =	pr[offset]		+	pr[offset+1]	+
@@ -159,7 +155,6 @@ for (y=1; y < img->height-1; y++) {
 	pr[offset] = cr / 4.0;
 	pg[offset] = cg / 4.0;
 	pb[offset] = cb / 4.0;
-
 	}
 }

@@ -237,6 +232,9 @@ return foo;
 }
 /* -------------------------------------------------------------------- */
 /* -------------------------------------------------------------------- */
+/*
+ *	XXX inplace filtering is a BAD IDEA
+ */
 int fimg_lissage_3x3(FloatImg *img)
 {
 int		foo;
@@ -265,6 +263,13 @@ if (foo) {
 	fprintf(stderr, "%s: lowpass -> %d\n", __func__, foo);
 	abort();
 	}
+
+foo = fimg_copy_data(&tmp, img);
+if (foo) {
+	fprintf(stderr, "%s: copy data -> %d\n", __func__, foo);
+	abort();
+	}
+
 foo = fimg_destroy(&tmp);
 if (foo) {
 	fprintf(stderr, "%s: destroy -> %d\n", __func__, foo);
--- a/funcs/fimg-fits.c
+++ b/funcs/fimg-fits.c
@@ -54,7 +54,7 @@ if (fits_create_file(&fptr, outname, &status)) {
 	}

 naxes[0] = src->width;		naxes[1] = src->height;
-if (verbosity) fimg_describe(src, "to be saved as FITS");
+if (verbosity > 1) fimg_describe(src, "to be saved as FITS");

 if ( fits_create_img(fptr,  bitpix, naxis, naxes, &status) ) {
 	fits_report_error(stderr, status);
--- a/funcs/fimg-libpnm.c
+++ b/funcs/fimg-libpnm.c
@@ -16,14 +16,14 @@ extern int		verbosity;
 /* --------------------------------------------------------------------- */
 static void print_struct_pam(struct pam *ppam, char *text)
 {
-printf("    text                %s\n", text);
-printf("    size                %d\n", ppam->size);
+printf("\ttext                %s\n", text);
+printf("\tsize                %d\n", ppam->size);

-printf("    format              %d\n", ppam->format);
-printf("    plainformat         %d\n", ppam->plainformat);
-printf("    width & height      %d %d\n", ppam->width, ppam->height);
-printf("    depth               %d\n", ppam->depth);
-printf("    maxval              %lu\n", ppam->maxval);
+printf("\tformat              %d 0x%04x\n", ppam->format, ppam->format);
+printf("\tplainformat         %d\n",	ppam->plainformat);
+printf("\twidth & height      %d %d\n", ppam->width, ppam->height);
+printf("\tdepth               %d\n", ppam->depth);
+printf("\tmaxval              %lu\n", ppam->maxval);
 }
 /* --------------------------------------------------------------------- */

@@ -36,13 +36,14 @@ FILE			*fp;
 fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
 #endif

+printf("    --- infos for '%s' ------------\n", fname);
+
 if (NULL==(fp=fopen(fname, "r"))) {
 	perror(fname);
 	exit(1);
 	}

 pnm_readpaminit(fp, &inpam, sizeof(inpam));
-
 print_struct_pam(&inpam, fname);

 fclose(fp);
--- a/funcs/fimg-tiff.c
+++ b/funcs/fimg-tiff.c
@@ -48,6 +48,7 @@ if (verbosity) {
 tiff = TIFFOpen(fname, "w");
 if (NULL==tiff) {
 	fprintf(stderr, "erreur TIFFOpen\n");
+	free(linebuff);
 	return -6;
 	}

--- a/funcs/geometry.c
+++ b/funcs/geometry.c
@@ -110,6 +110,9 @@ for (y=0; y<hd; y++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/*
+ *	this function can be optimized with direct pixel copy
+ */
 int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect)
 {
 int		xs, ys, xd, yd;
--- a/funcs/rampes.c
+++ b/funcs/rampes.c
@@ -62,15 +62,18 @@ for (x=0; x<img->width; x++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
-/*				nouveau 19 septembre 2022		 */
+/*				nouveau 19 septembre 2022
+ *
+ *	6 octobre 2023 : rajout du parametre 'fmax'
+ */

-int fimg_do_stripes(FloatImg *img, int mode)
+int fimg_do_stripes(FloatImg *img, float fmax, int mode)
 {
 int		x, y, quad;
 float		*ligne;
 float		fr, fg, fb;

-fprintf(stderr, ">>> %s ( %p %d )\n", __func__, img, mode);
+fprintf(stderr, ">>> %s ( %p %f %d )\n", __func__, img, fmax, mode);

 /*
 *	allocate and fill a lookup table
@@ -79,8 +82,10 @@ if (NULL==(ligne=malloc(img->width*sizeof(float)))) {
 	fprintf(stderr, "%s: malloc fail\n", __func__);
 	exit(1);
 	}
-for (x=0; x<img->width; x++)
+for (x=0; x<img->width; x++) {
 	ligne[x] = (float)x / (float)img->width;
+	ligne[x] *= fmax;
+	}

 /*
 *	build the pixels
--- a/funcs/recurse.c
+++ b/funcs/recurse.c
@@ -7,6 +7,7 @@
 #include   <math.h>
 #include  <stdint.h>
 #include  <sys/time.h>
+#include  <stdlib.h>

 #include   "../floatimg.h"

@@ -30,6 +31,10 @@ if (notused) {

 fprintf(stderr, "!!!!!! %s is a wip !!!!!\n", __func__);

+if (fimg_images_not_compatible(src, dst)) {
+	fprintf(stderr, "%s: compatibility  fatalerror\n", __func__);
+	exit(1);
+	}
 /*
 *	bon, maintenant, il faut plonger dans du code du
 *	siecle dernier et l'adapter a ce nouveau contexte
--- a/funcs/sfx0.c
+++ b/funcs/sfx0.c
@@ -36,7 +36,7 @@ return 0;
 }
 /* --------------------------------------------------------------------- */
 /*
- *	parameter fval is not used, why ?
+ *	parameter fval is used for what ?
 */
 int fimg_killcolors_b(FloatImg *fimg, float fval)
 {
--- a/funcs/sfx2.c
+++ b/funcs/sfx2.c
@@ -103,4 +103,7 @@ for (foo=0; foo<size; foo++) {
 return 0;
 }
 /* -------------------------------------------------------------- */
-
+/*
+ *			ici, il manque le quaternize :)
+ */
+/* -------------------------------------------------------------- */
--- a/funcs/sfx3.c
+++ b/funcs/sfx3.c
@@ -69,8 +69,8 @@ fprintf(stderr, ">>> %s ( %p %p %f 0x%04x )\n", __func__,
 #endif

 if (notused) {
-	fprintf(stderr, "notused was %d, must be 0 in %s\n",
-				notused, 		__func__);
+	fprintf(stderr, "%s: notused was %d, must be 0\n",
+			__func__, notused);
 	}

 halfval = fimg_get_maxvalue(src) / 2.0;
--- a/funcs/sfx4.c
+++ b/funcs/sfx4.c
@@ -83,4 +83,38 @@ for(idx=0; idx<surface; idx++) {
 return 0;
 }
 /* -------------------------------------------------------------- */
+int fimg_make_triptyq(FloatImg *src, FloatImg *dst, int notused)
+{
+int		x, y, sh, foo, ow;
+float		r, g, b, in[3];
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
+#endif
+
+if (fimg_images_not_compatible(src, dst)) {
+	fprintf(stderr, "%s : compatibility error\n", __func__);
+	return -8;
+	}
+
+fimg_clear(dst);
+
+ow = src->width / 3;
+for (y=0; y<src->height; y++) {
+	for (x=0; x<src->width/3; x++) {
+		r = g = b = 0.0;
+		for (sh=0; sh<3; sh++) {
+			foo =  fimg_get_rgb(src, (x*3)+sh, y, in);
+			r+=in[0], g+=in[1], b+=in[2];
+			}
+		for (sh=0; sh<3; sh++) {
+			fimg_plot_rgb(dst, x,        y,   r, 0, 0);
+			fimg_plot_rgb(dst, x+ow,     y,   0, g, 0);
+			fimg_plot_rgb(dst, x+(2*ow), y,   0, 0, b);
+			}
+		}
+	}
+
+return 0;
+}
 /* -------------------------------------------------------------- */
--- a/funcs/t.c
+++ b/funcs/t.c
@@ -26,7 +26,7 @@ enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
 			Geometrie, FileType, Mirror, KillRGB,
 			Pixelize,SplitLevel, DecompRgbz, DecompRgbg,
 			Rectangle, Dicom, Fakolor0, Fakolor3,
-			Fmorpho0, Fluffy  };
+			Fmorpho0, Fluffy, ThermoCol, TriPtyq  };
 typedef struct {
 	char	*name;
 	int	Cmd;
@@ -65,6 +65,8 @@ Command commands[] = {
 	{ "fakolor3",	Fakolor3	},
 	{ "fmorpho0",	Fmorpho0	},
 	{ "fluffy",	Fluffy		},
+	{ "thermocol",	ThermoCol	},
+	{ "triptyq",    TriPtyq		},
 	{ NULL,		0		}
 	} ;

@@ -266,6 +268,15 @@ switch(opt) {
 	case Fluffy:
 		foo = essai_rndfluffy(filename, outfile, 0);
 		break;
+	case ThermoCol:
+		foo = essai_thermocol(filename, outfile);
+		fprintf(stderr, "retour thermocolor = %d\n", foo);
+		break;
+	case TriPtyq:
+		foo = essai_triptyq(filename, outfile);
+		fprintf(stderr, "retour triptyq = %d\n", foo);
+		break;
+
 	default:
 		fprintf(stderr, "'%s' is a bad command\n", command);
 		exit(1);
--- a/funcs/tests.c
+++ b/funcs/tests.c
@@ -23,6 +23,39 @@ extern int		verbosity;
 #define W 1024
 #define H 768

+/* --------------------------------------------------------------------- */
+/* new Mon Apr  1 15:35:57 UTC 2024     -> sfx4.c			 */
+int essai_triptyq(char *infile, char *outfile)
+{
+FloatImg	src, dst;
+int		idx, foo;
+
+fprintf(stderr, ">>> %s ( %s %s )\n", __func__, infile, outfile);
+
+foo = fimg_create_from_dump(infile, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		infile);
+	return foo;
+	}
+fimg_clone(&src, &dst, 1);
+
+foo = fimg_make_triptyq(&src, &dst, 0);
+if (0 != foo) {
+	fprintf(stderr, "%s: make_triptyq -> %d\n", __func__, foo);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outfile, 0);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d exporting to '%s'\n", __func__,
+				foo, 		outfile);
+	return foo;
+	}
+
+return 0;
+}
+
 /* --------------------------------------------------------------------- */
 /*
 *	nouveau 30 octobre 2022     --> fmorpho.c
@@ -1173,3 +1206,37 @@ fimg_destroy(&dst);
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/* dans ma nouvelle maison du Gers, le 20 mars 2024 */
+int essai_thermocol(char *infile, char *outfile)
+{
+FloatImg	src, dst;
+int		foo;
+
+fprintf(stderr, ">>> %s ( '%s' '%s' )\n", __func__, infile, outfile);
+
+memset(&src, 0, sizeof(FloatImg));
+foo = fimg_create_from_dump(infile, &src);
+if (foo) {
+	fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
+	return foo;
+	}
+
+memset(&dst, 0, sizeof(FloatImg));
+foo = fimg_clone(&src, &dst, 0);
+if (foo) return -888;
+
+foo = fimg_auto_thermique(&src, &dst, 0);
+
+foo = fimg_export_picture(&dst, outfile, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result to %s\n", __func__,
+				foo, outfile);
+	return foo;
+	}
+
+fimg_destroy(&src);
+fimg_destroy(&dst);
+
+return 793;
+}
+/* --------------------------------------------------------------------- */
--- a/funcs/tests.h
+++ b/funcs/tests.h
@@ -30,6 +30,8 @@ int essai_detect_type(void);
 int fimg_essai_histo(FloatImg *src, char *outpic, int k); /* histogram.c */
 int essai_histogramme(char *fname, int k);
 int essai_0_fausses_couleurs(char *dstfile, int type);
+int essai_thermocol(char *infile, char *outfile);
+int essai_triptyq(char *infile, char *outfile);

 int essai_lecture_png(char *fname, char *outfile, int notused);

--- a/funcs/thermocolor.c
+++ b/funcs/thermocolor.c
@@ -0,0 +1,67 @@
+/*
+ *		FLOATIMG
+ *	fabriquer une pseudo-image thermique
+ *
+ * new: Wed Mar 20 16:55:09 UTC 2024 dans ma maison du Gers
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <string.h>
+#include  <stdint.h>
+
+#include  "../floatimg.h"
+
+extern int		verbosity;
+
+/* --------------------------------------------------------------------- */
+/*
+ *	parameter k in not used, but may be in the futur.
+ */
+int fimg_auto_thermique(FloatImg *src, FloatImg *dst, int k)
+{
+// int		x, y, off;
+int		idx, surface;
+
+float		seuil, gray;
+double		graymean;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p  %p  %d )\n", __func__, src, dst, k);
+#endif
+
+if (0!=k) {
+	fprintf(stderr, "%s: k must be 0, was %d\n", __func__, k);
+	}
+
+surface = src->width * src->height;
+// fprintf(stderr, "surface = %d\n", surface);
+
+graymean = 0.0;
+for (idx=0; idx<surface; idx++) {
+	gray = src->R[idx] + src->G[idx] + src->B[idx];
+	graymean += (double)gray;
+	}
+seuil = (float) (graymean / surface);
+// fprintf(stderr, "graymean = %f   seuil = %f\n", graymean, seuil);
+
+/*
+ *	please, explain this number brotching
+ */
+for (idx=0; idx<surface; idx++) {
+	gray = src->R[idx] + src->G[idx] + src->B[idx];
+	if (gray > seuil) {
+		dst->R[idx] = gray - seuil;
+		dst->B[idx] = seuil / 8.0;
+		}
+	else	{
+		dst->G[idx] = gray;
+		dst->B[idx] = seuil / 8.0;
+		}
+	}
+
+return 0;
+}
+
+
+/* --------------------------------------------------------------------- */
--- a/funcs/tpnm.c
+++ b/funcs/tpnm.c
@@ -1,10 +1,12 @@
 /*
+ *	testbed for using the Netpbm library
 */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include  <pam.h>
+
+#include  <pam.h>		/* Portable Any Map */

 #include "../floatimg.h"

--- a/funcs/utils.c
+++ b/funcs/utils.c
@@ -132,9 +132,11 @@ fprintf(stderr, ">>> %s ( %s %p %d )\n", __func__, str, r, notused);

 if (notused) {
 	fprintf(stderr, "notused was %d, must be 0 in %s\n",
-				notused, 		__func__);	}
+				notused, 		__func__);
+	}
+
+if (verbosity > 1) fprintf(stderr, "%s: parsing '%s'\n", __func__, str);

-if (verbosity > 1) fprintf(stderr, "parsing '%s'\n", str);
 foo = sscanf(str, "%d,%d,%d,%d", &w, &h, &x, &y);
 if (4 == foo) {
 	r->x = x, r->y = y, r->w = w, r->h = h;
--- a/install.sh
+++ b/install.sh
@@ -1,5 +1,7 @@
 #!/bin/bash -v

+set -e ; set -u
+
 cp	libfloatimg.a 	/usr/local/lib
 cp	floatimg.h 	/usr/local/include

@@ -8,7 +10,7 @@ cp	tools/mkfimg tools/fimg2pnm tools/fimgops 	\
 	tools/png2fimg tools/fimgstats tools/fimgfx	\
 	tools/cumulfimgs tools/fimg2text		\
 	tools/fimghalfsize				\
-	tools/fimgmetadata				\
+	tools/fimgmetadata tools/fimgfilters		\
 	tools/fimgextract				\
 	/usr/local/bin

--- a/lib/README.md
+++ b/lib/README.md
@@ -1,8 +1,26 @@
-# Fimg tools
+# Floatimg, the base/core library

-Need more explanations...
+## Data structures

+Image's pixels (floating point number, a `float` for C)
+are ordonned as an array of lines of single
+componant values. Every componant is in a separate array,
+who are *glued* together by an in-memory image descriptor.

-
-## Converting to/from rgb or gray 
+```
+#define MAGIC_FIMG	0x00F11F00
+typedef struct {
+  uint32_t	      magic;
+  int		      width;
+  int		      height;
+  int		      type;
+  float           fval;
+  int		      count;
+  float	          *R, *G, *B, *A;
+  FimgMetaData    mdatas;			// added 20230912
+  int		      reserved;
+	} FloatImg;
+```
+For the current state of this struc, look at the main
+[header file](../floatimg.h), located at the root of the project.

--- a/lib/alphachan.c
+++ b/lib/alphachan.c
@@ -13,11 +13,17 @@ extern int verbosity;           /* must be declared around main() */
 /* ---------------------------------------------------------------- */
 int fimg_add_alpha_chan(FloatImg *img)
 {
+
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+
 return -4;
 }
 /* ---------------------------------------------------------------- */
 int fimg_kill_alpha_chan(FloatImg *img)
 {
+
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+
 return -4;
 }
 /* ---------------------------------------------------------------- */
--- a/lib/contrast.c
+++ b/lib/contrast.c
@@ -116,13 +116,17 @@ int fimg_cos_01(FloatImg *s, FloatImg *d, double maxval)
 int		nbre, idx;
 double		dval;

+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p  %g )\n", __func__, s, d, maxval);
+#endif
+
 if (s->type != FIMG_TYPE_RGB) {
 	fprintf(stderr, "%s: type %d invalide\n",
 				__func__, s->type);
 	return -4;
 	}

-if (NULL==d) { d = s; }
+if (NULL==d) { d = s; }			/* In place */
 else	{
 	if (d->type != FIMG_TYPE_RGB) {
 		fprintf(stderr, "%s: dst type %d invalide\n",
--- a/lib/fimg-2gray.c
+++ b/lib/fimg-2gray.c
@@ -17,6 +17,7 @@ extern int verbosity;		/* must be declared around main() */
 /* --------------------------------------------------------------------- */
 /*
 *	floating resultat img MUST be allocated before calling this func.
+ *	and MUST be of type 'gray image'.
 */
 int fimg_mk_gray_from(FloatImg *src, FloatImg *dst, int k)
 {
@@ -43,15 +44,12 @@ if (FIMG_TYPE_RGB != src->type) {
 if (FIMG_TYPE_GRAY != dst->type) {
 	fprintf(stderr, "%s : bad dst type %d on %p\n", __func__, 
 				dst->type, dst);
-	/*
-	 * may be we can convert dst picture on the fly ?
-	 */
+	/* may be we can convert dst picture on the fly ? */
 	return -9;
 	}

 /* entering the main processing loop */
 nbb = src->width * src->height;
-
 for (foo=0; foo<nbb; foo++) {
 	dst->R[foo] = ( (src->R[foo] * kr) +
 			(src->G[foo] * kg) +
@@ -79,7 +77,6 @@ if (FIMG_TYPE_RGB != src->type || FIMG_TYPE_RGB != dst->type) {

 /* entering the main processing loop */
 nbb = src->width * src->height;
-
 for (foo=0; foo<nbb; foo++) {
 	dst->R[foo] = dst->G[foo] = dst->B[foo] =
 			(src->R[foo] + src->G[foo] + src->B[foo]) / 3.0;
--- a/lib/fimg-core.c
+++ b/lib/fimg-core.c
@@ -158,7 +158,7 @@ fprintf(stderr, ">>> %-25s ( %p )\n", __func__, fimg);
 #endif

 if (NULL == fimg) {
-	fprintf(stderr, "%s : parameter is null\n", __func__);
+	fprintf(stderr, "%s : descriptor address is null\n", __func__);
 	return -1;
 	}

--- a/lib/fimg-file.c
+++ b/lib/fimg-file.c
@@ -47,8 +47,8 @@ if (memcmp(filehead.magic, "FIMG", 4)) {
 	}

 /* XXX preparer la gestion des metadata */
-if ('a' == filehead.magic[4]) {
-	fprintf(stderr,"\n\t****** %s have metadata\n\n", fname);
+if ('a' == filehead.magic[4] && verbosity > 1) {
+	fprintf(stderr,"*** %s have metadata\n", fname);
 	}

 datas[0] = filehead.w;
@@ -87,15 +87,15 @@ if (FIMG_TYPE_RGB != fimg->type) {
 /* OK, we have to make a fake metadata chunk, if the caller
 * don't have one. Ugly, and nice */
 if (NULL == pmd) {
-	fprintf(stderr, ">>> %s making faked metadata\n", __func__);
+	// fprintf(stderr, ">>> %s making faked metadata\n", __func__);
 	foo = fimg_default_metadata(&fakemd, 3);
-	fprintf(stderr, "fakemd is at %p\n", &fakemd);
+	// fprintf(stderr, "fakemd is at %p\n", &fakemd);
 	pmd = &fakemd;
 	}
 else	{
 	/* OK, get some funky metadatas */
-	// fprintf(stderr, "%s get metadatas\n", __func__);
-	fprintf(stderr, "acqu fval=%f count=%d\n", pmd->fval, pmd->count);
+	fprintf(stderr, "%s: acqu fval=%f count=%d\n", __func__,
+				pmd->fval, pmd->count);
 	}

 fp = fopen(fname, "w");
@@ -260,7 +260,8 @@ if (	(filehead.w != where->width) ||

 /* XXX preparer la gestion des metadata */
 if ('a' == filehead.magic[4]) {
-	if (verbosity > 1) fprintf(stderr,"****** %s have metadata\n", fname);
+	if (verbosity > 1) fprintf(stderr,"%s say %s have metadata\n",
+					__func__, fname);
 	foo = fseek(fp, (long)sizeof(FimgMetaData), SEEK_CUR);
 	if (foo) {
 		fprintf(stderr, "%s: seek error\n", __func__);
@@ -305,7 +306,8 @@ fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, fname, head);

 /*
 *	may be we can crash coredump here if the head
- *	descriptor from caller is not blank ?
+ *	descriptor from caller is not blank ? Or just
+ *	display a warning ?
 */

 fp = fopen(fname, "r");
@@ -338,10 +340,13 @@ if (foo) {
 */
 if ('a' == filehead.magic[4]) {
 	if (verbosity > 1)
-		{ fprintf(stderr, "%s: %s has metadata\n", __func__, fname); }
+		{ fprintf(stderr, "in %s, %s has metadata\n", __func__, fname); }
+	/* old school processing... 
 	foo = fseek(fp, (long)sizeof(FimgMetaData), SEEK_CUR);
-	if (foo) {
-		fprintf(stderr, "%s : shit hit the fan\n", __func__);
+	*/
+	foo = fread(&head->mdatas, sizeof(FimgMetaData), 1, fp);
+	if (1 != foo) {
+		fprintf(stderr, "%s: shit hit the fan %d\n", __func__, foo);
 		abort();
 		}
 	}
--- a/lib/fimg-math.c
+++ b/lib/fimg-math.c
@@ -116,7 +116,37 @@ for (idx=0; idx<surface; idx++) {
 	else if (fval > mmvals[5])	mmvals[5] = fval;
 	}

-return -0;
+return 0;
+}
+/* ---------------------------------------------------------------- */
+/* new: Fri Oct  6 19:51:28 UTC 2023
+ *
+ * can compute the maxima of a lot of pictures...
+ */
+
+int fimg_max_of_max(FloatImg *img, float maxes[3])
+{
+float		localmax[3];
+int		idx, surface;
+float		fval;
+
+localmax[0] = localmax[1] = localmax[2] = -1e9;
+
+surface = img->width * img->height;
+for (idx=0; idx<surface; idx++) {
+	fval = img->R[idx];
+	if (fval > localmax[0])		localmax[0] = fval;
+	fval = img->G[idx];
+	if (fval > localmax[1])		localmax[1] = fval;
+	fval = img->B[idx];
+	if (fval > localmax[2])		localmax[2] = fval;
+	}
+
+if (localmax[0] > maxes[0])	maxes[0] = localmax[0];
+if (localmax[1] > maxes[1])	maxes[1] = localmax[1];
+if (localmax[2] > maxes[2])	maxes[2] = localmax[2];
+
+return 0;
 }
 /* ---------------------------------------------------------------- */
 int fimg_meanvalues(FloatImg *head, float means[4])
@@ -171,9 +201,7 @@ if (head->type != FIMG_TYPE_RGB) {
 	}

 for (foo=0; foo<(head->width*head->height); foo++) {
-	add  = head->R[foo];
-	add += head->G[foo];
-	add += head->B[foo];
+	add  = head->R[foo] + head->G[foo] + head->B[foo];
 	head->R[foo] = head->G[foo] = head->B[foo] = add / 3.0;
 	}
 return 0;
@@ -380,7 +408,6 @@ for (idx=0; idx<surface; idx++) {
 return 0;
 }
 /* ---------------------------------------------------------------- */
-
 /*            Warning: this function is _very_ slow                 */
 void fimg_drand48(FloatImg *fi, float kmul)
 {
@@ -396,12 +423,14 @@ if (fi->type != FIMG_TYPE_RGB) {
 	return;
 	}
 nbre = fi->width * fi->height;
+
+fprintf(stderr, "in %s, drand48() is %f\n", __func__, drand48());
+
 for (idx=0; idx<nbre; idx++) {
 	fi->R[idx] = drand48() * kmul;
 	fi->G[idx] = drand48() * kmul;
 	fi->B[idx] = drand48() * kmul;
 	}
-
 }
 /* ---------------------------------------------------------------- */

--- a/lib/metadata.c
+++ b/lib/metadata.c
@@ -1,5 +1,10 @@
 /*
 *              metadata.c
+ *		----------
+ *
+ *	This is not a stable version. You must expect problems,
+ *	and the first one was time_t 32 vs. 64 bits.
+ *
 */

 #include  <stdio.h>
@@ -14,22 +19,6 @@

 extern int verbosity;           /* must be declared around main() */

-/* ---------------------------------------------------------------- */
-/*
- *	specific function because magic field is NOT an asciiz !
- */
-static void puts_magic_8(char *ptr, FILE *fp)
-{
-int		foo;
-
-fputs("magic                = ", fp);
-fputc('[', fp);
-for (foo=0; foo<8; foo++) {
-	fputc(ptr[foo], fp);
-	}
-fputc(']', fp); fputc('\n', fp);
-fflush(fp);
-}
 /* ---------------------------------------------------------------- */
 int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused)
 {
@@ -46,16 +35,16 @@ if (notused) {
 				notused, 		__func__);
 	}
 if (NULL != title) {
-	fprintf(stderr, "==== metadate for %s\n", title);
+	fprintf(stderr, "======== metadata for %s\n", title);
 	}
 if (verbosity) {
 	fprintf(stderr, "sizeof(metadata)     = %ld\n",    \
 				sizeof(FimgMetaData));
-	puts_magic_8(pmd->magic, stderr);
+	fprintf(stderr, "    Magic [%08x]\n", pmd->magic);
 	}

 /* SHOW TIMESTAMP HERE */
-fprintf(stderr, "seconds sc. epoch    = %ld\n", pmd->timestamp.tv_sec);
+fprintf(stderr, "secs from epoch      = %ld\n", pmd->timestamp.tv_sec);
 fprintf(stderr, "date & time          = %s",   ctime(&pmd->timestamp.tv_sec));
 doubletime = (double)pmd->timestamp.tv_sec +			\
 		(double)pmd->timestamp.tv_usec / 1e6;
@@ -75,13 +64,19 @@ fputc('\n', stderr);
 return 0;
 }
 /* ---------------------------------------------------------------- */
+/*
+ *	those values may be loaded from a config file ?
+ */
 int fimg_default_metadata(FimgMetaData *pmd, int bla)
 {
 int			foo;
 struct timeval		tvl;

+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pmd, bla);
+#endif
+
 memset(pmd, 0, sizeof(FimgMetaData));
-memcpy(pmd->magic, "metadata", 8);

 /* set timestamp here ? */
 /* CHALLENGE ACCEPTED */
@@ -99,10 +94,11 @@ else	{
 	memcpy(&(pmd->timestamp), &tvl, sizeof(struct timeval));
 	}

+pmd->magic	   = MAGIC_MDATA;
 pmd->cpid          = getpid();		// we are the creator, no ?
 pmd->count         = 1;			// mmmm...
 pmd->fval          = 255.0;		// Ok
-strcpy(pmd->idcam, "<noname>");
+strcpy(pmd->idcam, "<noname camera>");
 pmd->origin        = 0xdeadbeef;	// classic joke, sorry
 pmd->reserved[0]   = bla;
 pmd->reserved[7]   = 0x55445544;	// magic number is a crime
@@ -154,12 +150,13 @@ if (1 != foo) {

 fclose(fp);		/* got all needed datas */

-if (memcmp(metadata.magic, "metadata", 8)) {
-	fprintf(stderr, "'%s' invalid metadata\n", fname);
-	puts_magic_8(metadata.magic, stderr);
-	return -6;
+if (MAGIC_MDATA != metadata.magic) {
+	fprintf(stderr, "%s: magic was %08X, wtf?\n", __func__,
+					metadata.magic);
+	return -4;
 	}

+
 memcpy(pmd, &metadata, sizeof(FimgMetaData));

 return 0;
--- a/lib/t.c
+++ b/lib/t.c
@@ -23,8 +23,7 @@ int			foo;
 fprintf(stderr, "-------- %s ( %s ) --------\n", __func__, fname);

 foo = fimg_default_metadata(&Md, 0);
-
-// foo = fimg_show_metadata(&Md, "default from t.c", 0);
+foo = fimg_show_metadata(&Md, "default from t.c", 0);

 foo = fimg_get_metadata_from_file(fname, &Md);
 fprintf(stderr, "%s : get metadata -> %d\n", fname, foo);
--- a/scripts/.gitignore
+++ b/scripts/.gitignore
@@ -0,0 +1,7 @@
+
+
+*.fits
+*.tiff
+*.tif
+*.png
+
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -1,7 +1,8 @@
 # Exemples de scripts

 _Attention_, ce ne sont que des exemples, pas forcément adaptés
-à une utilisation dans le monde réel.
+à une utilisation dans le monde réel. Mais vous pouvez vous en
+inspirer pour vos usecases personnels.

 ## shoot.sh

@@ -20,5 +21,13 @@ en dur dans le code.
 Comment générer des videos psychotiques avec un peu de bash.
 Ce script est expliqué dans la documentation PDF.

+## capture.sh & conf.sh

+Ce [script](./capture.sh) sert à capturer une séquence d'image depuis
+une webcam.
+Deux choses à noter : il utilise un fichier de configuration
+(`source [./conf.sh](./conf.sh)) pour ajuster son fonctionnement, et il
+extrait juste une portion de l'image capturée. Une belle avancée,
+puisque cela ajoute quelques possibilités de recadrage dès
+la prise de vue.

--- a/scripts/capture.sh
+++ b/scripts/capture.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# 		CAPTURE
+
+source ./conf.sh
+
+DEVICE="/dev/video0"
+GOPT=" -v -s 1920x1080  -p 0 -n 10"
+OUTD=$GRABDIR
+TMPG="/dev/shm/tmpgrab.fimg"
+
+for idx in $(seq  0 2399)
+do
+
+	# take the picz
+	${GRAB} -d ${DEVICE} ${GOPT} -o ${TMPG}
+
+	# display $TMPG
+
+	# only take the good spot
+	fimg=$(printf "%s/%05d.fimg" ${OUTD} ${idx})
+	${EXTR}  -o ${fimg} ${TMPG} 800,600,560,240
+
+	# display ${fimg} ;  exit
+
+	echo
+	sleep $DELAY_GRAB
+
+done
+
--- a/scripts/conf.sh
+++ b/scripts/conf.sh
@@ -0,0 +1,34 @@
+
+# Sat Jul  8 10:41:58 UTC 2023
+
+#
+#	location of some tools
+#
+
+GRAB="$HOME/Devel/FloatImg/v4l2/grabvidseq"
+MKFX="$HOME/Devel/FloatImg/tools/fimgfx"
+MDAT="$HOME/Devel/FloatImg/tools/fimgmetadata"
+EXTR="$HOME/Devel/FloatImg/tools/fimgextract"
+
+INTERPOLATOR="$HOME/Devel/FloatImg/Fonderie/interpolator"
+FONDERIE="$HOME/Devel/FloatImg/Fonderie/fonderie"
+SINGLEPASS="$HOME/Devel/FloatImg/Fonderie/singlepass"
+
+#
+#	working directories
+#
+GRABDIR="rush"
+GIFDIR="gif89a"
+
+#
+#	text plotting conf
+FONT="Noto-Sans-Bold"
+KERNING=1
+SIGNATURE="... tTh 2023 ..."
+
+#
+#	filter chains for fondulations
+#
+IF="cos01:colmixa:pow2"
+OF="shiftln0:liss3x3"
+
--- a/scripts/demo-fimgfx.sh
+++ b/scripts/demo-fimgfx.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+source="00000.fimg"
+tmpimg="/dev/shm/demofx.fimg"
+
+effects=$(fimgfx -l)
+
+for fx in $effects
+do
+
+	echo "============= " $fx
+	dst="${fx}.png"
+	echo "       " ${source} ${dst}
+
+	fimgfx -v ${fx} ${source} ${tmpimg}
+
+	convert $tmpimg				\
+		-fill black -stroke white	\
+		-strokewidth 1			\
+		-pointsize 34			\
+		-font "Noto-Sans-Bold"		\
+		-gravity South-East		\
+		-annotate +32+10 "${fx}"	\
+		${dst}
+
+done
+
--- a/scripts/echomix.sh
+++ b/scripts/echomix.sh
@@ -26,9 +26,9 @@ for idx in $(seq 0 $NBRE)
 do
 	# build the two input filenames ...
 	#
-	imgA=$(printf "$SRCDIR/%04d.fimg" $idx)
+	imgA=$(printf "$SRCDIR/%05d.fimg" $idx)
 	vb=$(( $(( idx + OFFS )) % NBRE))
-	imgB=$(printf "$SRCDIR/%04d.fimg" $vb)
+	imgB=$(printf "$SRCDIR/%05d.fimg" $vb)

 	#	... and the output filename
 	#
--- a/tools/.gitignore
+++ b/tools/.gitignore
@@ -17,5 +17,8 @@ cumulfimgs
 fimgops
 fimgfx
 fimgmetadata
+fimgfilters
+
+*.gif
 *.png
 *.tiff
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -13,9 +13,12 @@ DEPS = ../floatimg.h  ../libfloatimg.a Makefile
 all:	fimg2pnm mkfimg png2fimg fimgstats fimg2png		\
 	fimg2tiff fimg2text fimg2fits				\
 	addpnm2fimg cumulfimgs fimgops fimgfx			\
-	fimgmetadata						\
+	fimgmetadata fimgfilters				\
 	fimghalfsize fimgextract

+fimgfilters:	fimgfilters.c $(DEPS)
+	gcc $(COPT) $< ../libfloatimg.a -lm -o $@
+
 fimgmetadata:	fimgmetadata.c $(DEPS)
 	gcc $(COPT) $< ../libfloatimg.a -lm -o $@

@@ -33,7 +36,7 @@ mkfimg:		mkfimg.c  $(DEPS)
 	gcc $(COPT) $< ../libfloatimg.a -lm -o $@

 fimgops:		fimgops.c  $(DEPS)
-	gcc $(COPT) $< ../libfloatimg.a -o $@
+	gcc $(COPT) $< ../libfloatimg.a -lm -o $@

 fimgfx:		fimgfx.c  $(DEPS)
 	gcc $(COPT) $< ../libfloatimg.a 		\
--- a/tools/README.md
+++ b/tools/README.md
@@ -1,8 +1,9 @@
 # Images en virgule flottante, les outils.

-Dans tous les cas, vous pouvez utiliser l'option `-h` pour avoir des
-explications sur ce que vous pouvez faire, et l'option `-v` pour suivre
-l'avancée des travaux.
+Dans tous les cas, vous pouvez utiliser l'option `-v`
+(qui est bien mieux en premier sur la ligne de commande)
+pour suivre l'avancée des travaux et l'option `-h` pour
+avoir des explications sur ce que vous pouvez faire, 

 ## mkfimg

@@ -11,7 +12,22 @@ Un [../scripts/demo-mkfimg.sh](script) permet de créer toutes
 les images disponibles.

 L'option `-m` rajoute des méta-données, cette option 
-**ne** doit **pas** encore être utilisée dans la vrai vie.
+**ne** doit **pas** encore être utilisée dans la vrai vie, ymmv.
+
+## cumulfimg
+
+Procède à l'accumulation de plusieurs images flottantes,
+c'est-à-dire en faire la moyenne.
+Le nom par défaut du fichier résultant est `out.fimg`, mais peut
+être changé avec l'option `-o`. Avec `-g` l'image de sortie
+sera en niveau de gris.
+
+Ce logicel gagnerait peut-être à utiliser un accumulateur
+intermédiaire en double précision pour les cas limite,
+ou une [méthode](https://orlp.net/blog/taming-float-sums/)
+plus adaptée.
+
+

 ## fimgops
 ```
@@ -24,30 +40,56 @@ options:

 ## fimgfx

-effects:
+Available effects:
+
        cos01 cos010 pow2 sqrt gray0 cmixa xper desat ctr2x2 mirror 
        shift0 trimul classtrial binarize trinarize hilightr 
+        abs clamp fakol0 morph0 morph4 morph8 thermocol
+
+Un [../scripts/demo-fimgfx.sh](script) permet de créer toutes
+les images avec les effets disponibles.
+Vous vous rendrez vite compte que certains ne semblent rien faire,
+mais regardez plus attentivement...

 ## fimgstats

-Compute some useless numbers...
+Compute some useless numbers, specially for the enduser...

 ## fimg2pnm - fimg2png - fimg2tiff - fimg2fips

-Exportation d'image flottante vers divers formats. Certains d'entre eux
-ne sont gérés que de façon très rudimentaire.
+Exportation d'image flottante vers divers (et trop rares) formats.
+Certains d'entre eux ne sont gérés que de façon très rudimentaire.

 ## fimg2text

 Nouveau de l'année 2020+1 : exfiltrer toutes des données d'une image flottante
 afin de les rendre machinables. Voir aussi *fimgmetadata*.

+```
+tth@redlady:~/Devel/FloatImg/tools$ ./fimg2text bar.fimg | head -5
+0 0 123.701111 269.273682 10.732136
+1 0 109.500832 265.568481 26.176439
+2 0 128.529694 292.033844 37.591236
+3 0 98.910492 234.900467 17.132524
+4 0 187.679092 386.155609 36.663834
+```
+
 ## fimgmetadata

-Nouveau avril 2022. Need more doc...
-Voir aussi *fimg2text*.
+Affichage des informations diverses stockées dans un fichier `.fimg`,
+comme la date de prise de vue ou les réglages du logiciel
+de capture.
+
+Expect problems with `time_t` on 32 vs. 64 bits. Fix in
+progress.

 ## fimgextract

-nouveau novembre 2022.
+En avril 2024, il sert à tester une nouvelle fonctionnalité :
+la recopie des méta-données de l'image source.
+
+    $ fimgextract [options] source.fimg width,height,xpos,ypos
+
+Les options utiles : `-o out.fimg` pour nommer le fichier de
+sortie, et `-m` qui demande la recopie des metadatas. 

--- a/tools/cumulfimgs.c
+++ b/tools/cumulfimgs.c
@@ -6,6 +6,7 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <stdint.h>
+#include  <string.h>

 #include  "../floatimg.h"

@@ -40,12 +41,14 @@ void help(int v)
 puts("");
 puts("$ cumulfimgs a.fimg b.fimg c-fimg ...");
 puts("cumulator options :");
+puts("\t-a\tcompute average");
 puts("\t-g\tconvert to gray level");
+puts("\t-m\tcompute the max of the maxes");
 puts("\t-o\tname of output file");
 puts("\t-s\trescale end image");
 puts("\t-v\tincrease verbosity");
 puts("");
-if (verbosity) { puts("Xperiment"); fimg_print_version(v); }
+fimg_print_version(v);
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@@ -59,17 +62,19 @@ int		to_gray		= 0;
 int		experiment	= 0;
 int		rescale		= 0;
 int		src_loaded	= 0;
+int		minmax		= 0;

 char		*output_file	= "out.fimg";
 FloatImg	accu, temp;
-float		vals[6];
+float		vals[3];

 g_width = g_height = 0;

-while ((opt = getopt(argc, argv, "gho:svx")) != -1) {
+while ((opt = getopt(argc, argv, "ghmo:svx")) != -1) {
 	switch(opt) {
 		case 'g':	to_gray = 1;			break;
 		case 'h':	help(1);			break;
+		case 'm':	minmax++;			break;
 		case 'o':	output_file = optarg;		break;
 		case 's':	rescale = 1;			break;
 		case 'v':	verbosity++;			break;
@@ -83,9 +88,12 @@ if (verbosity)		fprintf(stderr, "------ cumulfimgs ------\n");
 fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
 #endif

+memset(vals, 0, 3*sizeof(float));
+
 for (idx=optind; idx<argc; idx++) {
 #if DEBUG_LEVEL 
-	fprintf(stderr, "%5d   %s\n", idx, argv[idx]);
+	fprintf(stderr, "----------------  %s\n", argv[idx]);
+	fflush(stderr);
 #endif
 	foo = testfile(argv[idx]);
 	if (foo) {
@@ -93,8 +101,15 @@ for (idx=optind; idx<argc; idx++) {
 		exit(1);
 		}

+	/*
+	 *	load the picture, create a clone of the first
+	 */
 	if ( ! src_loaded ) {
 		foo = fimg_create_from_dump(argv[idx], &accu);
+		if (foo) {
+			fprintf(stderr, "create from dump -> %d\n", foo);
+			exit(1);
+			}
 		fimg_clone(&accu, &temp, 0);
 		src_loaded = 1;
 		}
@@ -104,8 +119,20 @@ for (idx=optind; idx<argc; idx++) {
 			fprintf(stderr, "load from dump -> %d\n", foo);
 			exit(1);
 			}
-		fimg_add_2(&temp, &accu);
 		}
+
+	if (minmax) {
+		/*
+		 * print the maximum values and compute the
+		 * maximum of all the maximums
+		 */
+		foo = fimg_max_of_max(&temp, vals);
+		// fprintf(stderr, "%5d max of max %9.3f  %9.3f  %9.3f\n",
+		//			idx, vals[0], vals[1], vals[2]);
+		}
+
+	fimg_add_2(&temp, &accu);
+
 	compte++;
 	}

@@ -114,11 +141,9 @@ if (rescale) {
 	fimg_div_cste(&accu, (float)compte);
 	}

-/*	XXX 		*/
-if (experiment) {

-	}
-/*	XXX 		*/
+fprintf(stderr, "max of max  %9.3f   %9.3f   %9.3f\n",
+				vals[0], vals[1], vals[2]);


 if (to_gray) {
@@ -156,6 +181,8 @@ if (verbosity) {
 				vals[4], vals[5], vals[5]-vals[4]);
 	}

+fimg_destroy(&accu);	fimg_destroy(&temp);
+
 return 0;
 }
 /* --------------------------------------------------------------------- */
--- a/tools/fimg2fits.c
+++ b/tools/fimg2fits.c
@@ -32,21 +32,23 @@ if (foo) {

 fimg_destroy(&fimg);

-return -1;
+return 0;
 }
 /* ----------------------------------------------------------------- */
 static void help(int k)
 {
 puts("export to FITS format");
 puts("\t-p  select colorplane : R, G, B");
+puts("\t    default is blue");
+puts("\t-v  increase verbosity");
 fimg_print_version(k);
 }
 /* ----------------------------------------------------------------- */

 int main(int argc, char *argv[])
 {
-int		opt;
-int		plane = '?';
+int		opt, foo;
+int		plane = 'b';

 while ((opt = getopt(argc, argv, "p:hv")) != -1) {
 	switch(opt) {
@@ -62,8 +64,11 @@ if (2 != argc-optind) {
 	exit(1);
 	}

-export_fimg_plane_as_fits(argv[optind], argv[optind+1], plane);
-
+foo = export_fimg_plane_as_fits(argv[optind], argv[optind+1], plane);
+if (foo) {
+	fprintf(stderr, "export_fimg_plane_as_fits --> %d\n", foo);
+	exit(1);
+	}
 return 0;
 }
 /* ----------------------------------------------------------------- */
--- a/tools/fimg2png.c
+++ b/tools/fimg2png.c
@@ -92,6 +92,7 @@ if (2 != argc-optind) {
 foo = convertir_fimg_en_PNG(argv[optind], argv[optind+1], to_gray);
 if (foo) {
 	fprintf(stderr, "%s : got a %d from convertor\n", argv[0], foo);
+	exit(1);
 	}

 return 0;
--- a/tools/fimg2text.c
+++ b/tools/fimg2text.c
@@ -21,14 +21,10 @@ int		x, y;
 float		rgb[3];

 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %25s ( %p '%s' %d )\n", __func__,
+fprintf(stderr, ">>> %s ( %p '%s' 0x%x )\n", __func__,
 			src, fname, flags);
 #endif

-if (0 != flags) {
-	fprintf(stderr, "bad flags in %s\n", __func__);
-	}
-
 fp = NULL;					/* molly guard */
 if (strcmp("-", fname)) {			/* real file */
 	fprintf(stderr, "real file '%s'\n", fname);
@@ -38,6 +34,12 @@ else {
 	}

 fp = stdout;					/* XXX */
+
+/*
+ *	put a first line, so we can load those data with R
+ */
+if (flags & 1) { fputs("X Y R G B\n", fp); }
+
 for (y=0; y<src->height; y+=steps) {
 	for (x=0; x<src->width; x+=steps) {
 		fimg_get_rgb(src, x, y, rgb);
@@ -49,6 +51,9 @@ for (y=0; y<src->height; y+=steps) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/*
+ *	This function must be in the libfloatimg !
+ */
 static int normalize(FloatImg *pimg, float vmax)
 {
 float		mmv[6], maxi, coef;
@@ -85,14 +90,15 @@ return 0;
 }
 /* --------------------------------------------------------------------- */
 int convertir_fimg_en_machinable(char *srcname, char *dstname,
-					int steps, float norm)
+					int steps, float norm, int header)
 {
 int		foo, infos[3];
+int		flg;
 FloatImg	fimg;

 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %25s ( '%s' '%s' %d %f )\n", __func__,
-			srcname, dstname, steps, norm);
+fprintf(stderr, ">>> %s ( '%s' '%s' %d %f %d )\n", __func__,
+			srcname, dstname, steps, norm, header);
 #endif

 if (steps < 1) {
@@ -100,12 +106,14 @@ if (steps < 1) {
 	exit(1);
 	}

+flg = 0;
+if (header)	flg |= 1;
+
 foo = fimg_fileinfos(srcname, infos);
 if (foo) {
 	fprintf(stderr, "'%s' get dims -> %d\n", srcname, foo);
 	return foo;
 	}
-
 if (verbosity) {
 	fprintf(stderr, "%s: image '%s' is %d x %d  %s\n", 
 				__func__,
@@ -119,16 +127,12 @@ if (foo) {
 	return -1;
 	}

-if (verbosity) {
-	// fimg_describe(&fimg, srcname);
-	fprintf(stderr, "normalize to %f\n", norm);
-	}
 if (norm > 0.0) {
-	// fprintf(stderr, "normalize %p\n", &fimg);
+	if (verbosity) fprintf(stderr, "normalize to %f\n", norm);
 	foo = normalize(&fimg, norm);
 	}

-foo = export_as_machinable(&fimg, dstname, steps, 0);
+foo = export_as_machinable(&fimg, dstname, steps, flg);
 if (foo) {
 	fprintf(stderr,"%s: err %d on export\n", __func__, foo);
 	}
@@ -141,9 +145,10 @@ void help(int k)
 {
 puts("usage:\n\tfimg2text [options] foo.fimg > bar.csv");
 puts("options:");
-puts("\t-v\t\tincrease verbosity");
-puts("\t-n 3.14\t\tnormalize picture");
+puts("\t-n Value\tnormalize picture if Value > 0.0");
 puts("\t-s N\t\tsteps on x & y");
+puts("\t-T\t\tadd header with colon name");
+puts("\t-v\t\tincrease verbosity");
 if (verbosity) {
 	printf("*** compiled: %s at %s\n", __DATE__, __TIME__);
 	fimg_print_version(k);
@@ -156,15 +161,17 @@ int main(int argc, char *argv[])
 {
 int		foo, opt;
 int		steps = 1;
-float		norm_val = 222.0;	/* < 0 : don't normalize */
+int		header = 0;
+float		norm_val = -1;	/* < 0 : don't normalize */
 // char		separator = ' ';

-while ((opt = getopt(argc, argv, "f:hn:s:v")) != -1) {
+while ((opt = getopt(argc, argv, "f:hn:s:Tv")) != -1) {
 	switch(opt) {
 		// case 'f':	separator = optarg[0];		break;
 		case 'v':	verbosity++;			break;
 		case 'h':	help(1);			exit(1);
 		case 's':	steps = atoi(optarg);		break;
+		case 'T':	header = 1;			break;
 		case 'n':	norm_val = atof(optarg);	break;
 		default:	exit(1);
 		}
@@ -175,7 +182,8 @@ if (1 != argc-optind) {
 	exit(1);
 	}

-foo = convertir_fimg_en_machinable(argv[optind], "-", steps, norm_val);
+foo = convertir_fimg_en_machinable(argv[optind], "-",
+				steps, norm_val, header);
 if (foo) {
 	fprintf(stderr, "%s : got a %d from convertor\n", argv[0], foo);
 	return 1;
--- a/tools/fimgextract.c
+++ b/tools/fimgextract.c
@@ -6,11 +6,30 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <stdint.h>
+#include  <string.h>

 #include  "../floatimg.h"

 int		verbosity;		// nasty global var.

+/* --------------------------------------------------------------------- */
+/* nouveau - Mon Apr  8 11:52:18 UTC 2024 */
+int copy_metadata(FloatImg *src, FloatImg *dst)
+{
+FimgMetaData	*mdsrc, *mddst;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
+#endif
+
+mdsrc = &(src->mdatas);    mddst = &(dst->mdatas);
+if (verbosity) fprintf(stderr, "%s:  %p --> %p\n", __func__, mdsrc, mddst);
+
+mdsrc->reserved[1] = 0x55555555;
+memcpy(mddst, mdsrc, sizeof(FimgMetaData));
+
+return 0;
+}
 /* --------------------------------------------------------------------- */
 /* nouveau ~ 2 octobre 2022 */
 int extractor(char *srcname, char *dstname, FimgArea51 *rect)
@@ -18,7 +37,9 @@ int extractor(char *srcname, char *dstname, FimgArea51 *rect)
 FloatImg	src, dst;
 int		foo;

+#if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %s  %s  %p )\n", __func__, srcname, dstname, rect);
+#endif

 if (verbosity) {
 	print_rectangle((char *)__func__, rect);
@@ -47,9 +68,13 @@ if (foo) {
 	return foo;
 	}

-// debug code XXX (void)fimg_save_as_pnm(&dst, "f.pnm", 0);
+/*	XXX
+ *	may be we can also copy the metadate from src to dst ?
+ *	with an option on the command line ?
+ */
+foo = copy_metadata(&src, &dst);

-foo = fimg_dump_to_file(&dst, dstname, 0);
+foo = fimg_dumpmd_to_file(&dst, dstname, NULL, 0);
 if (foo) {
 	fprintf(stderr, "%s: dumping datas to '%s' give us a %d\n",
 			__func__, dstname, foo);
@@ -67,8 +92,9 @@ printf("-- Fimg Extractor -- lib v%d -- %s %s\n", FIMG_VERSION,

 puts("usage:\n\tfimgextract [options] source.fimg width,height,xpos,ypos");
 puts("options:");
+puts("\t-m\t\tcopy metadata bloc");
 puts("\t-o out.fimg\tname the output file");
-puts("\t-v\t\tmake be a blabla box");
+puts("\t-v\t\tmake me a blabla box");
 puts("\t-x\t\tenable crashy feature");
 exit(0);
 }
@@ -85,6 +111,7 @@ char		*output_file	= "out.fimg";
 while ((opt = getopt(argc, argv, "ho:vx")) != -1) {
 	switch(opt) {
 		case 'h':	help();				break;
+		case 'm':					break;
 		case 'o':	output_file = optarg;		break;
 		case 'v':	verbosity++;			break;
 		case 'x':	experiment++;			break;
@@ -92,23 +119,25 @@ while ((opt = getopt(argc, argv, "ho:vx")) != -1) {
 		}
 	}

-fprintf(stderr, "argc = %d  optind = %d\n", argc, optind);
-for (idx=optind; idx<argc; idx++) {
+if (verbosity) {
+	fprintf(stderr, "argc = %d  optind = %d\n", argc, optind);
+	for (idx=optind; idx<argc; idx++) {
 		fprintf(stderr, "   %5d   %s\n", idx, argv[idx]);
 		}
+	}

 if (argc==optind) {
-	fprintf(stderr, "wuh ?\n");
+	fprintf(stderr, "what the fsck ?\n");
 	exit(0);
 	}

-foo = parse_rectangle(argv[argc-1], &area, 0);
+foo = parse_rectangle(argv[optind+1], &area, 0);
 if (4 != foo) {
 	fprintf(stderr, "%s: parse_rectangle --> %d\n", argv[0], foo);
 	exit(1);
 	}

-foo = extractor(argv[argc-2], output_file, &area);
+foo = extractor(argv[optind], output_file, &area);
 if (foo) {
 	fprintf(stderr, "%s: extractor --> %d\n", __func__, foo);
 	exit(1);
--- a/tools/fimgfilters.c
+++ b/tools/fimgfilters.c
@@ -0,0 +1,85 @@
+/*
+			FIMGFILTERS
+			===========
+ new: Sun Oct  8 05:51:05 UTC 2023
+*/
+
+#include  <stdio.h>
+#include  <string.h>
+#include  <stdint.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+#include  <time.h>
+
+#include  "../floatimg.h"
+
+int		verbosity;
+
+/* --------------------------------------------------------------------- */
+int filtre_image(char *infname, char *outfname, int type)
+{
+FloatImg	src, dst;
+int		foo;
+
+static FimgFilter3x3   filtre = {
+                {
+                2.0,    3.0,    2.0,
+                3.0,    4.0,    3.0,
+                2.0,    3.0,    2.0,
+                },
+        1.0/24.0,   0.0
+        };
+
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__, infname, outfname, type);
+fimg_show_filter(NULL, &filtre);
+#endif
+
+if (0 != type) {
+	fprintf(stderr, "%s: bad type %d\n", __func__, type);
+	}
+
+if ((foo = fimg_create_from_dump(infname, &src))) {
+	fprintf(stderr, "read error on '%s' is %d\n", infname, foo);
+	exit(2);
+	}
+if ((foo = fimg_clone(&src, &dst, 0))) {
+	fprintf(stderr, "clone error on %p is %d\n", &src, foo);
+	exit(3);
+	}
+
+foo = fimg_filter_3x3(&src, &dst, &filtre);
+if (foo) {
+	fprintf(stderr, "%s: filtre -> %d\n", __func__, foo);
+	exit(4);
+	}
+
+foo = fimg_dump_to_file(&dst, outfname, 0);
+if (foo) {
+	fprintf(stderr, "dumping to file give us a %d\n", foo);
+	exit(5);
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+int		foo;
+
+if (3 != argc) {
+	fprintf(stderr, "usage: %s in.fimg out.fimg\n", argv[0]);
+	exit(1);
+	}
+
+fprintf(stderr, "    +++ %s +++\n", argv[0]);
+
+foo = filtre_image(argv[1], argv[2], 0);
+fprintf(stderr, "    filtrage -> %d\n", foo);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+
--- a/tools/fimgfx.c
+++ b/tools/fimgfx.c
@@ -29,7 +29,7 @@ enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
 		Fx_classtrial, Fx_mirror, Fx_shift0, Fx_trimul,
 		Fx_xper, Fx_binarize, Fx_trinarize, Fx_hilight_R,
 		Fx_absolute, Fx_clamp, Fx_fakol0, Fx_fakol3,
-		Fx_morph0, Fx_morph4, Fx_morph8 };
+		Fx_morph0, Fx_morph4, Fx_morph8, Fx_thermocol };

 Fx fx_list[] = {
 	{ "cos01",		Fx_cos01,	0,	1 },
@@ -57,6 +57,7 @@ Fx fx_list[] = {
 	{ "morph0",		Fx_morph0,	0,	1 },
 	{ "morph4",		Fx_morph4,	0,	1 },
 	{ "morph8",		Fx_morph8,	0,	1 },
+	{ "thermocol",		Fx_thermocol,	0,	1 },
 	{ NULL,			0,		0,	0 }
 	};

@@ -272,6 +273,9 @@ switch (action) {
 	case Fx_morph8:
 		foo = fimg_filtre_morpho_0(&src, &dest, 8);	break;

+	case Fx_thermocol:
+		foo = fimg_auto_thermique(&src, &dest, 0);	break;
+
 	default:
 		fprintf(stderr, "%s %s : %d is bad action\n",
 					__FILE__, __func__, action);
--- a/tools/fimgmetadata.c
+++ b/tools/fimgmetadata.c
@@ -16,7 +16,7 @@
 int		verbosity;

 enum comId {	C_timestamp, C_daytime, C_count, C_fval, C_cpid, C_origin, 
-		C_idcam, C_all };
+		C_idcam, C_reserved, C_all, C_dayhour };

 typedef struct {
 	char		*name;
@@ -26,11 +26,13 @@ typedef struct {
 Cmd Cmd_list[] = {
 	{ "timestamp",		C_timestamp	},
 	{ "daytime",		C_daytime	},
+	{ "dayhour",		C_dayhour	},
 	{ "cpid",		C_cpid		},
 	{ "count",		C_count		},
 	{ "fval",		C_fval		},
 	{ "origin",		C_origin	},
 	{ "idcam",		C_idcam		},
+	{ "reserved",		C_reserved	},
 	{ "all",		C_all		},
 	{ NULL,			0,		}
 	};
@@ -57,10 +59,35 @@ for (n=0, cmd=Cmd_list; cmd->name; cmd++, n++) {
 return -1;		/* NOT FOUND */
 }
 /* --------------------------------------------------------------------- */
+void list_commands(void)
+{
+Cmd		*cmd;
+int		n;
+
+fputs("Commands:", stderr);
+for (n=0, cmd=Cmd_list; cmd->name; cmd++) {
+	n += fprintf(stderr, " %s", cmd->name);
+	if (n > 40) {
+		fputs("\n         ", stderr);
+		n = 0;
+		}
+	}
+fputs("\n", stderr);
+}
+/* --------------------------------------------------------------------- */
+int show_reserved(FimgMetaData *pmd)
+{
+int foo;
+for (foo=0; foo<8; foo++) printf("%08x ", pmd->reserved[foo]);
+puts("");
+return 0;
+}
+/* --------------------------------------------------------------------- */
 int get_print_metadata(char *fname, char *command)
 {
 int		foo, action;
 FimgMetaData	metadata;
+time_t		tstamp;

 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( '%s' '%s' )\n", __func__, fname, command);
@@ -73,11 +100,15 @@ if (foo)	return foo;
 action = lookup_cmd(command);
 // fprintf(stderr, "    command '%s' -> %d\n", command, action);

+tstamp = metadata.timestamp.tv_sec;
+
 switch(action)	{
 	case C_timestamp:
-		printf("timestamp %ld\n", metadata.timestamp.tv_sec);  break;
+		printf("timestamp %ld\n", tstamp);		break;
 	case C_daytime:
-		printf("%s\n", ctime(&metadata.timestamp.tv_sec));    break;
+		printf("%s\n", ctime(&tstamp));			break;
+	case C_dayhour:
+		printf("%s\n", ctime(&tstamp));			break;
 	case C_count:
 		printf("count %d\n", metadata.count);		break;
 	case C_fval:
@@ -88,6 +119,8 @@ switch(action)	{
 		printf("origin 0x%x\n", metadata.origin);	break;
 	case C_idcam:
 		printf("camid \"%s\"\n", metadata.idcam);	break;
+	case C_reserved:
+		show_reserved(&metadata);			break;
 	case C_all:
 		fimg_show_metadata(&metadata, fname, 0);	break;
 	default:
@@ -101,6 +134,7 @@ void help(void)
 {
 fprintf(stderr, "*** Fimg Metadata Reader (%s, %s)\n", __DATE__, __TIME__);
 fimg_print_version(1);
+list_commands();
 exit(0);
 }
 /* --------------------------------------------------------------------- */
--- a/tools/fimgops.c
+++ b/tools/fimgops.c
@@ -66,6 +66,7 @@ static void help(int lj)

 puts("usage:\n\tfimgops [options] A.fimg B.fimg operator D.fimg");
 puts("options:");
+puts("\t-a\t\texport absolute value");
 // puts("\t-g              convert output to gray");
 printf("\t-k N.N\t\tset float value (def=%.3f)\n", global_fvalue);
 puts("\t-v\t\tincrease verbosity");
@@ -107,13 +108,15 @@ return foo;
 int main(int argc, char *argv[])
 {
 int		foo, opt, action;
+int		absolute = 0;
 char		*operator;
 FloatImg	srcA, srcB, dest;

 global_fvalue = 0.5;

-while ((opt = getopt(argc, argv, "hk:v")) != -1) {
+while ((opt = getopt(argc, argv, "ahk:v")) != -1) {
 	switch(opt) {
+		case 'a':	absolute = 1;			break;
 		case 'g':					break;
 		case 'h':	help(0);			break;
 		case 'k':	global_fvalue = atof(optarg);	break;
@@ -182,6 +185,11 @@ if (foo) {
 					operator, foo);
 	}

+if (absolute) {
+	if (verbosity) fprintf(stderr, "compute abs of %p\n", &dest);
+	fimg_absolute(&dest);
+	}
+
 foo = fimg_dump_to_file(&dest, argv[optind+3], 0);
 if (foo) {
 	fprintf(stderr, "dumping datas to file give us a %d\n", foo);
--- a/tools/fimgstats.c
+++ b/tools/fimgstats.c
@@ -39,7 +39,7 @@ int		foo;
 float		vals[6];

 if (verbosity) {
-	fprintf(stderr, "%s  numbers from %p :\n", __func__, fimg); 
+	fprintf(stderr, "%s from %p :\n", __func__, fimg); 
 	}

 fimg_printhead(fimg);
--- a/tools/mkfimg.c
+++ b/tools/mkfimg.c
@@ -75,7 +75,7 @@ int		foo, cc;

 puts("Usage:\tmkfimg [options]  quux.fimg width height");

-puts("\t-k N.N\tgive a float parameter");
+puts("\t-k N.N\tgive a float multiplier");
 puts("\t-L\tlist howto make a pic");
 puts("\t-m\tadd faked metadata");

@@ -128,7 +128,7 @@ for (foo=0; foo<argc; foo++)
 #endif

 if (type < 0) {
-	fprintf(stderr, "type '%s' is unknow\n", tname);
+	fprintf(stderr, "%s: type '%s' is unknow\n", argv[0], tname);
 	exit(2);
 	}

@@ -153,12 +153,6 @@ switch (nbargs) {

 fname = argv[optind];

-if (verbosity>1) {
-	fprintf(stderr, "*** mkfimg *** %s %s *** pid %ld\n",
-				__DATE__, __TIME__, (long)getpid());
-	fimg_print_version(0);
-	}
-
 if (verbosity)   fprintf(stderr, "::: %s is making  '%s'  %dx%d, type %d\n",
 					argv[0], fname, width, height, type);

@@ -178,15 +172,17 @@ switch(type) {
 	case T_DRAND48:		fimg_drand48(&fimg, fvalue);		break;
 	case T_GRAY:		fimg_rgb_constant(&fimg, fvalue, fvalue, fvalue);
 									break;
-	case T_HDEG_A:		fimg_hdeg_a(&fimg, 1.0);	break;
-	case T_VDEG_A:		fimg_vdeg_a(&fimg, 1.0);	break;
+	case T_HDEG_A:		fimg_hdeg_a(&fimg, fvalue);		break;
+	case T_VDEG_A:		fimg_vdeg_a(&fimg, fvalue);		break;
 	case T_TPAT0:		fimg_test_pattern(&fimg, 0, fvalue);	break;
 	case T_MIRCOL1:		fimg_mircol_1(&fimg, fvalue);		break;
 	case T_BLOUP:		fimg_draw_something(&fimg);		break;
-	case T_STRIPES:		fimg_do_stripes(&fimg, 0);	break;
+	case T_STRIPES:		fimg_do_stripes(&fimg, fvalue, 0);	break;
 	case -1:		exit(1);
 	}

+
+
 if (verbosity > 1) fprintf(stderr, "%s: end of switch\n", __func__);

 /* NO ERROR CONTROL ? WTF ? */
--- a/v4l2/grabvidseq.c
+++ b/v4l2/grabvidseq.c
@@ -402,17 +402,18 @@ foo = format_from_extension(outfile);
 switch (foo) {
 	case FILE_TYPE_FIMG:
 		if (add_metadata) {
-			fimg_default_metadata(&metadata, 51);
+			fimg_default_metadata(&metadata, 0x51);
 			/* copy some values to mdstruct */
 			metadata.fval  = to_save->fval;
 			metadata.count = to_save->count;
-			// fprintf(stderr, "-> save '%s' with metadata\n",
-			//			outfile);
+			fprintf(stderr, "-> save '%s' with metadata\n",
+						outfile);
 			foo = fimg_dumpmd_to_file(to_save, outfile,	\
 							&metadata, 0);
 			}
 		else	{
 			foo = fimg_dump_to_file(to_save, outfile, 0);
+			fprintf(stderr, "%s no dump of metadata ?\n", outfile);
 			}
 		break;
 	case FILE_TYPE_PNM:
Author	SHA1	Message	Date
tTh	8202df9a63	check for the export directory (singlepass)	2024-11-13 13:37:54 +01:00
tTh	67ba638690	check for the export directory (interpolator)	2024-11-13 13:35:22 +01:00
tTh	e8a7bf28e3	check for the export directory (fonderie)	2024-11-12 22:58:55 +01:00
tTh	b19107d71b	add two molly-guard	2024-11-12 12:50:31 +01:00
tTh	fabe94792b	add two molly-guard	2024-11-12 12:49:43 +01:00
tTh	d1e67f7397	add a missing exit()	2024-11-12 11:36:57 +01:00
tTh	28453e862a	msg when export dir not writable	2024-11-11 17:24:03 +01:00
tTh	2147d4b164	tweaking help text	2024-11-11 17:15:53 +01:00
tTh	b0983ab18b	msg bug + better exit	2024-11-11 17:13:20 +01:00
tTh	08fcf513cc	checking export directory, first try	2024-11-10 13:55:25 +01:00
tTh	e6b72e5faa	minor changes	2024-10-27 16:37:10 +01:00
tTh	756766ca42	+ libncurses-dev	2024-10-12 00:34:27 +02:00
tTh	9ede78fa5d	signaler création répertoire pour export	2024-10-11 23:54:23 +02:00
tTh	506bf39393	cosmetic	2024-10-11 23:30:41 +02:00
tTh	26e82619fb	little tweak	2024-09-29 20:14:13 +02:00
tTh	91440e7ea5	add shift to zero filter	2024-09-29 19:04:10 +02:00
tTh	5fbff721d8	cosmetic	2024-09-29 18:46:38 +02:00
tTh	d510e56d44	various enhancements	2024-08-29 18:24:01 +02:00
tTh	2a8348f0f9	hide a non-essential msg	2024-08-29 18:23:03 +02:00
tTh	f473a58f75	cosmetic + bla	2024-08-28 22:41:47 +02:00
tTh	556e1ad825	bump the version	2024-08-28 22:24:18 +02:00
tTh	23842595fd	add a default target	2024-08-28 21:23:55 +02:00
tTh	6069c45b5a	working on readme files	2024-08-28 21:23:09 +02:00
tTh	4e7debaae6	better doc for the tools	2024-05-26 01:38:30 +02:00
tTh	b7c32d24f3	mkfimg gradient now use the cli parameter	2024-05-01 21:42:55 +02:00
tTh	4f27e491b1	cosmetic	2024-05-01 21:40:44 +02:00
tTh	11e87efd67	cosmetic	2024-05-01 21:38:19 +02:00
tTh	85dbf384bd	bla	2024-05-01 12:32:06 +02:00
tTh	8c4b9a6aa0	bla	2024-05-01 12:30:53 +02:00
tTh	bb2b3b72de	add -a option for absolute value of op result	2024-05-01 12:28:23 +02:00
tTh	7586423d23	display reserved words of metadata	2024-04-08 12:35:51 +02:00
tTh	bdfb3e279d	fimgextract can now copy metadata	2024-04-08 11:52:42 +02:00
tTh	e00c6b8fb2	add togray filter	2024-04-06 20:25:51 +02:00
tTh	cce8e0b86c	cleanup	2024-04-04 02:21:41 +02:00
tTh	f5ce5a3699	oups...	2024-04-04 02:17:50 +02:00
tTh	0d092f89af	add missing proto	2024-04-01 18:10:07 +02:00
tTh	79f4e011a5	add triptyq effect to fonderie	2024-04-01 18:04:40 +02:00
tTh	a433176c54	added the triptyq fx to library	2024-04-01 17:49:14 +02:00
tTh	02b4493659	minor changes	2024-04-01 00:07:34 +02:00
tTh	fe3bc9d64c	better messages	2024-03-31 00:15:47 +01:00
tTh	346ea08aba	fix two error messages	2024-03-28 16:01:58 +01:00
tTh	e0c5695ab8	better messages	2024-03-27 12:20:28 +01:00
tTh	3604f41a57	better messages	2024-03-27 12:19:41 +01:00
tTh	953462eb6e	thermocolr updated	2024-03-27 08:50:17 +01:00
tTh	4ecce5bdc0	maybe fix a bug in trinitron	2024-03-27 08:36:18 +01:00
tTh	65c0212108	update fx demo script	2024-03-27 07:27:52 +01:00
tTh	681899b06d	less verbosity is better	2024-03-25 12:45:15 +01:00
tTh	fc9b6571f3	add a little warning	2024-03-24 15:24:09 +01:00
tTh	f1d42c74a6	add deoc and warning	2024-03-24 15:20:04 +01:00
tTh	36c9dc3e88	add warning messages	2024-03-24 15:15:42 +01:00
tTh	fa5e4d5acd	add thermocol fx to fonderie	2024-03-24 15:07:29 +01:00
tTh	5afb90bedf	small clean	2024-03-21 16:10:39 +01:00
tTh	387c25401c	fix typo in debug code	2024-03-21 16:10:06 +01:00
tTh	9fb09f401f	thermocol is in fimgfx	2024-03-20 20:07:48 +01:00
tTh	83e577b89a	thermocolor, first try	2024-03-20 18:44:06 +01:00
tTh	c598c4a2c0	ok boomer	2023-11-29 11:28:21 +01:00
tTh	b33a752af7	bla	2023-11-29 11:26:56 +01:00
tTh	9c5849e299	filter is coming again	2023-11-29 11:25:43 +01:00
tTh	9dd2064b7a	nano cleanup	2023-11-29 11:24:58 +01:00
tTh	a438ab9362	better error message	2023-10-29 00:47:25 +02:00
tTh	381f329810	mute an useless message	2023-10-18 17:27:38 +02:00
tTh	3bd387f0a9	tuning of the "normalize" option	2023-10-18 16:08:51 +02:00
tTh	085e19942a	cosmetic	2023-10-10 23:51:56 +02:00
tTh	152beddcb7	fimg2text can now add column names	2023-10-09 10:48:39 +02:00
tTh	c1b6f9ae40	cosmetic	2023-10-09 03:13:50 +02:00
tTh	2c407e5dd9	silent a message	2023-10-08 10:26:03 +02:00
tTh	c6b75d3bba	working on lowpass filter	2023-10-08 09:38:42 +02:00
tTh	12347e9066	add a molly guard	2023-10-08 07:28:57 +02:00
tTh	9e9535221f	enhanced mkfimg: do_stripe take a maxlevel parameter	2023-10-08 07:10:02 +02:00
tTh	1f1398f9f2	cosmetic	2023-10-07 21:05:55 +02:00
tTh	2699476135	new func: the max of max	2023-10-07 19:19:49 +02:00
tTh	cfe9f8cdae	small patches	2023-10-06 21:34:11 +02:00
tTh	5d139312e2	enhance fimgmetadata -h	2023-09-11 11:09:31 +02:00
tTh	2c14368cd5	more work on cachengn	2023-07-20 12:03:43 +02:00
tTh	658ef3ab08	bla	2023-07-17 14:59:48 +02:00
tTh	8b8c1b466f	cosmetic	2023-07-17 13:52:47 +02:00
tTh	817982c074	tweak	2023-07-17 13:43:31 +02:00
tTh	6a4b2f7c32	change blanks count default	2023-07-17 09:47:56 +02:00
tTh	36fcc15b0a	cosmetic	2023-07-17 08:56:23 +02:00
tTh	8c0f55b7cb	OUPS!	2023-07-17 07:44:39 +02:00
tTh	ee5e081031	new effect 'suprbg' added to Fonderie	2023-07-16 14:14:29 +02:00
tTh	d23a35849a	trying a new effect	2023-07-16 12:39:49 +02:00
tTh	82ffe1c2cc	bla du dimanche soir	2023-07-10 02:26:57 +02:00
tTh	0a482a7316	fixed	2023-07-08 13:10:47 +02:00
tTh	2c1687f82b	a few oops...	2023-07-08 12:43:00 +02:00
tTh	0f245582d5	a few doc/exemples for blz	2023-07-08 12:18:55 +02:00
tTh	c8faa77904	img path is now 5 digits	2023-07-08 12:17:16 +02:00
tTh	03763a4dfb	scories clean	2023-07-07 12:36:29 +02:00
tTh	54d9a9939d	big clean on extractor	2023-07-07 12:27:48 +02:00
tTh	488893f6a3	bla	2023-07-07 12:25:47 +02:00
tTh	e9ca450584	little refactoring	2023-07-07 10:08:57 +02:00
tTh	3fd604b14a	better message	2023-07-06 19:43:47 +02:00
tTh	0169fbade7	bla	2023-07-06 10:54:18 +02:00