check for the export directory (singlepass)

.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
@@ -54,22 +45,6 @@ v4l2/*.tiff
 v4l2/video-infos
 v4l2/nc-camcontrol
 
-tools/fimg2png
-tools/fimg2pnm
-tools/fimg2tiff
-tools/fimg2fits
-tools/fimg2text
-tools/fimgstats
-tools/fimghalfsize
-tools/mkfimg
-tools/png2fimg
-tools/addtga2fimg
-tools/addpnm2fimg
-tools/cumulfimgs
-tools/fimgops
-tools/fimgfx
-tools/*.png
-tools/*.tiff
 
 Fonderie/*.o
 Fonderie/*.png
@@ -83,17 +58,4 @@ Fonderie/singlepass
 Fonderie/crapdef.h
 Fonderie/crapstr.h
 
-experiment/assemblage
-experiment/extracteur
-experiment/*.fimg
-experiment/*.pnm
-experiment/*.o
-experiment/muxplanes
-experiment/movepixels
-experiment/tcache
 
-contrib/fimg2povhf
-contrib/*.tga
-contrib/pov.stderr
-contrib/*.png
-contrib/*.gif

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
 
@@ -41,19 +41,19 @@ singlepass:	singlepass.c ${DEPS} ${OBJS} Makefile
 #	some files are magically generated, sorry.
 #
 crapdef.h:	crapulors.liste Makefile craplist2h.awk
-	./craplist2h.awk   < $< | tee $@
+	< $< ./craplist2h.awk > $@
 
 crapstr.h:	crapulors.liste Makefile craplist2str.awk
-	./craplist2str.awk < $< | tee $@
+	< $< ./craplist2str.awk > $@
 
 # ---------------------------------------------------------
 #
 #	a lot of silly functions
 #
-crapulator.o:	crapulator.c ${DEPS} Makefile
+crapulator.o:	crapulator.c $(DEPS) Makefile
 	gcc ${COPT} -c $<
 
-fifo.o:	fifo.c fifo.h Makefile
+fifo.o:	fifo.c fifo.h $(DEPS) Makefile
 	gcc ${COPT} -c $<
 
 sfx.o:	sfx.c ${DEPS} Makefile
@@ -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 $<
+
 # ---------------------------------------------------------

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...
@@ -20,16 +22,15 @@ destinés à augmenter la kitchitude du produit final. Ils peuvent être chainé
 les uns après les autres, à l'entrée et à la sortie du process
 de floutagement.
 
-Ces filtres ont chacun un nom et un numéro. que l'on peut (en théorie)
-utiliser indistinctement dans une chaine de filtres. 
+Ces filtres ont chacun un nom, utilisable dans une chaine de filtres. 
 L'option `-L` de ces logiciels permet d'obtenir la liste des filtres.
+Pour ne rien filtrer, utilisez le filtre `none`, il est là pour ça.
 
-Une chaine de filtres est constituée d'une liste de nom ou de numéro
+Une chaine de filtres est constituée d'une liste de nom
 de filtre, séparés par le caractère `:`, une façon de faire très
-classique dans notre univers, en fait. Et si on veut prendre des risques,
-on doit continuer à appeler les filtres par leur numéro, jdçjdr.
+classique dans notre univers, en fait.
 
-`mirsplit:ctr2x2:3:killlines`
+`mirsplit:ctr2x2:killlines`
 
 Nous allons donc voir quelques exemples un peu plus loin.
 
@@ -70,12 +71,14 @@ GRABDIR="/spool/tth/fonderie"
 FONDEUR="$HOME/Devel/FloatImg/Fonderie/fonderie"
 GLOB=${GRABDIR}'/?????.fimg'
 
-${FONDEUR} -I "$GLOB" -E cos01:25 -T 30 -F 2:classtrial
+${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 suffit d'encoder toutes les images générées dans
+ensuite il vous suffira d'encoder toutes les images générées dans
 `p8/` (répertoire de sortie par défaut)
 avec une incantation de ffmpeg :
 
@@ -95,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
@@ -112,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
 ```
@@ -130,12 +133,15 @@ 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
 ```
 
 ## Conclusion
 
+Tout cela est bien rigolo :)
+
 
 **Use the source, Luke**
 

Fonderie/craplist2h.awk

@@ -6,18 +6,19 @@
 #
 
 BEGIN	{
-	print "// -----------------------------------"
+	print "// -------------------------------------"
 	print "// generated file, do not edit by hand !"
-	print "// -----------------------------------"
+	print "// -------------------------------------"
 	}
 
 #		$1 is the badly brain-designed numeric id
 #		$2 is the user name of the filter
 
 	{
-	printf "#define    CR_%s    (%d)\n", $2, $1
+	name = sprintf("CR_%s", $2)
+	printf "#define    %-15s    (%d)\n", name, $1
 	}
 
 END	{
-	print "// generated file, do not edit by hand !"
+	print "\n// generated file, do not edit by hand !"
 	}

Fonderie/craplist2str.awk

@@ -5,10 +5,10 @@
 #		is includet by 'crapulator.c'
 #
 BEGIN	{
-	print "// -----------------------------------"
-	print "// generated file, do not edit by hand";
-	print "// -----------------------------------"
-	print "Crapulor CrapL[] = {";
+	print "// -------------------------------------"
+	print "// generated file, do not edit by hand !";
+	print "// -------------------------------------"
+	print "Crapulor  CrapL[] = {";
 	}
 
 #		$1 is the badly brain-designed numeric id
@@ -16,12 +16,13 @@ BEGIN	{
 #		$3 and $4 are two not used parameters
 #
 	{
-	printf "   { CR_%s, \"%s\", %d, %f }, // id=%d\n",
-                        $2,    $2,   $3, $4,           $1;
+	name = sprintf("CR_%s", $2)
+	printf "   { %-14s,  \"%s\",       %d, %f },      // #%d\n",
+                        name,    $2,   $3, $4,           $1;
 	}
 
 END	{
 	print "   { -1, NULL }"
 	print " };"
-	print "// generated file, do not edit by hand"
+	print "// ! generated file, do not edit by hand !"
 	}

Fonderie/crapulator.c

@@ -82,7 +82,7 @@ FloatImg		img;
 int 			foo, retval;
 FimgFilter3x3		*pfiltre;
 
-FimgFilter3x3	lowpass = {
+static FimgFilter3x3	lowpass = {
 		{
 		1.0,	2.0,	1.0,
 		2.0,	4.0,	2.0,
@@ -91,7 +91,7 @@ FimgFilter3x3	lowpass = {
 	16.0,	0.0
 	};
 
-FimgFilter3x3	hipass = {
+static FimgFilter3x3	hipass = {
 	/* there was a bug with this filter */
 		{
 		-1.0,	-1.0,	-1.0,
@@ -101,7 +101,7 @@ FimgFilter3x3	hipass = {
 	1.0,	0.0
 	};
 
-FimgFilter3x3	diagonal = {
+static FimgFilter3x3	diagonal = {
 	/* there was a bug with this filter */
 		{
 		4.0,	1.0,	0.0,
@@ -195,6 +195,22 @@ int			ret;
 memset(&tmp, 0, sizeof(FloatImg));
 fimg_clone(img, &tmp, 0);
 ret = fimg_pixelize_h_rnd(img, &tmp, k);
+if (verbosity > 1) fprintf(stderr, "in %s, pixelize H rnd -> %d\n", 
+					__func__, ret);
+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);
 
@@ -212,6 +228,34 @@ ret = fimg_decomp_rgbz_color(img, &tmp, k);
 fimg_copy_data(&tmp, img);
 fimg_destroy(&tmp);
 
+return ret;
+}
+/* -------------------------------------------------------------- */
+/* nouveau 14 mai 2022 */
+static int run_gr2popcol(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+ret =  graylevel2popcolors(img, &tmp, k);
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
+return ret;
+}
+/* -------------------------------------------------------------- */
+/*	new Sun Feb 12 11:30:02 CET 2023			  */
+static int run_rndfluffy(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+ret = fimg_make_rndfluffy_lines(img, &tmp, k);
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
 return ret;
 }
 /* -------------------------------------------------------------- */
@@ -220,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;
 }
 /* -------------------------------------------------------------- */
@@ -385,14 +454,6 @@ switch (idFx) {
 		retval = plot_multidots(image, 42);
 		break;
 
-	case CR_message:
-		fprintf(stderr, "### msg from pid %d, fval=%f ###\n",
-						getpid(), fval);
-		/* here, we can display stats ! */
-		fimg_describe(image, "in crapulator");
-		retval = 0;
-		break;
-
 	case CR_nothing:
 		retval = do_something(image, 3);
 		break;
@@ -404,9 +465,12 @@ switch (idFx) {
 	case CR_pixelizh:
 		retval = run_pixelize_0(image, 8);
 		break;
+	case CR_pixelizv:
+		retval = run_pixelize_0(image, 32);
+		break;
 
 	case CR_pixelrand:
-		retval = run_pixelize_random(image, -1);
+		retval = run_pixelize_random(image, 16);
 		break;
 
 	case CR_splitlevel:
@@ -414,16 +478,48 @@ switch (idFx) {
 		break;
 
 	case CR_decrgbzc:
-		retval = run_decomprgbz_color(image, -1);
+		retval = run_decomprgbz_color(image, 0);
 		break;
 	case CR_decrgbzg:
-		retval = run_decomprgbz_gray(image, -1);
+		retval = run_decomprgbz_gray(image, 0);
 		break;
 
 	case CR_hilightr:
 		retval = fimg_highlight_color(image, image, 'R', 1.717);
 		break;
 
+	case CR_gr2popcol:
+		retval = run_gr2popcol(image, -1);
+		break;
+
+	case CR_fluffy:
+		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);
@@ -459,13 +555,25 @@ void list_crapulors(char *texte)
 int		idx;
 
 #define OUT	stdout
-if (NULL!=texte) 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++) {
-	fprintf(OUT, " %-12s | %4d  |  %5d  |  %8.3f\n",
+	if (verbosity) {
+		fprintf(OUT, " %-12s | %4d  |  %5d  |  %8.3f\n",
 					CrapL[idx].name,
 					CrapL[idx].id,
 					CrapL[idx].ipar,
 					CrapL[idx].fpar);
+		}
+	else	{
+		fprintf(OUT, "%s\n", CrapL[idx].name);
+		}
 	}
 #undef OUT
 }

Fonderie/crapulors.liste

@@ -41,5 +41,12 @@
 49	splitlevel	1	1
 50	decrgbzc	1	99
 51	decrgbzg	1	99
-99	message		1	1.0
+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
+

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

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) {
@@ -229,6 +231,7 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
 				break;
 		case 'v':	verbosity++;
 				break;
+		default:	exit(1);
 		}
 	}
 
@@ -237,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);
@@ -258,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;
 }

Fonderie/glitches.c

@@ -151,36 +151,38 @@ int		pass, szimg, osrc, odst;
 szimg = picture->width * picture->height;
 
 for (pass=0; pass<szimg/32; pass++) {
-
 	osrc = rand() % szimg;
 	odst = rand() % szimg;
 	picture->R[odst] = (picture->R[osrc] + picture->R[odst]) / 2.0;
 	picture->G[odst] = (picture->G[osrc] + picture->G[odst]) / 2.0;
 	picture->B[odst] = (picture->B[osrc] + picture->B[odst]) / 2.0;
-
 	}
 
 return 0;
 }
+/*   --------------------------------------------------------------   */
+/*
+ *	FIXME XXX
+ */
 int random_blocks(FloatImg *picture, int percent)
 {
 int		x, y;
 
 if ( (picture->width%16) || (picture->height%16) )
 	{
-	fprintf(stderr, "%s: %d%d bad dims\n", __func__,
+	fprintf(stderr, "WARNING %s: %dx%d bad dims\n", __func__,
 				picture->width, picture->height);
+	// return -1;
 	}
 
-for (y=0; y<picture->height; y+=16) {
-	for (x=0; x<picture->width; x+=16) {
+for (y=16; y<picture->height-16; y+=16) {
+	for (x=16; x<picture->width-16; x+=16) {
 		if (percent < (rand()%100) ) {
 			un_petit_flou_8x8(picture, x,   y);
 			un_petit_flou_8x8(picture, x+8, y);
 			un_petit_flou_8x8(picture, x,   y+8);
 			un_petit_flou_8x8(picture, x+8, y+8);
 			}
-
 		}
 	}
 

Fonderie/interpolator.c

@@ -17,6 +17,7 @@
 
 #include  "../floatimg.h"
 
+#include  "utilfuncs.h"
 #include  "fifo.h"
 #include  "glitches.h"
 #include  "crapulator.h"
@@ -54,10 +55,14 @@ 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 && verbosity) {
+	fprintf(stderr, "\tWTF? in %s, sort method was ZERO?\n", __func__);
+	}
+
 nombre = ptr_glob->gl_pathc;
 
 /* allocate the array for the sorting action */
@@ -66,7 +71,7 @@ if (NULL==idxvalues) {
 	fprintf(stderr, "MEMORY ERROR in %s\n", __func__);
 	exit(1);
 	}
-fprintf(stderr, "IdxValues array at %p\n", idxvalues);
+// fprintf(stderr, "IdxValues array at %p\n", idxvalues);
 
 *ptr_idxval = idxvalues;
 average     = 0.0;
@@ -104,7 +109,7 @@ if (verbosity > 1) {
 average /= (double)nombre;
 *p_average = average;
 
-fprintf(stderr, "\naverage %f\n", average);
+fprintf(stderr, "\naverage of ??? is %f\n", average);
 
 return 0;
 }
@@ -122,22 +127,22 @@ int		foo, idx, ipng, w, h, step;
 int		curpix;
 int		iarray[3];
 char		*cptr, line[200];
-float		coef, value;
+float		coef;
 double		meanmetric;
 IdxValue	*idx_values;			/* gni? */
 
-fprintf(stderr, "  interpolate from '%s' to '%s' with %d steps.\n",
+fprintf(stderr, "    interpolate from '%s' to '%s' with %d steps.\n",
 			pattern, outdir, Nsteps);
 
 if (negative) fprintf(stderr, "%s: negative ON\n", __func__);
 
 memset(&globbuf, 0, sizeof(glob_t));
 foo = glob(pattern, 0, NULL, &globbuf);
-fprintf(stderr, "globbing '%s' -> %d, %d files found\n",
+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;
@@ -155,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);
@@ -172,10 +177,10 @@ 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;
 		}
-	value = idx_values[idx].value;		/* WTF ? */
 
 	/* here was the input filter */
 	foo = filterstack_run(0, &B, 0);
@@ -236,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);
 }
@@ -253,10 +256,11 @@ int		opt;
 int		sort = 0;
 char		*InFchain  = "0";
 char		*OutFchain = "0";
+char		*out_dir = "p8/";
 
-fprintf(stderr, "*** %s : compiled by tTh, %s %s\n", __FILE__,
+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 */
@@ -275,6 +279,7 @@ while ((opt = getopt(argc, argv, "E:F:hLnS:v")) != -1) {
 		case 'S':	sort = atoi(optarg);	break;
 		case 'v':	verbosity++;		break;
 		case 'n':	negative = 1;		break;
+		default:	exit(1);
 		}
 	}
 
@@ -287,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);
@@ -303,6 +320,7 @@ if (verbosity) {
 	fprintf(stderr, "\toutput dir        '%s'\n", argv[optind+1]);
 	fprintf(stderr, "\tsrc filter        '%s'\n", InFchain);
 	fprintf(stderr, "\tout filter        '%s'\n", OutFchain);
+	fprintf(stderr, "\tsort               %d\n", sort);
 	}
 
 if (verbosity > 1) {

Fonderie/sfx.c

@@ -21,6 +21,88 @@
  */
 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 */
+
+int graylevel2popcolors(FloatImg *src, FloatImg *dst, int k)
+{
+int		x, y;
+float		rgb[3];
+float		theoric_maxval, real_maxv;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, k);
+#endif
+
+theoric_maxval = src->fval * src->count;
+real_maxv    = fimg_get_maxvalue(src);
+#if DEBUG_LEVEL
+fprintf(stderr, "maxval:   theoric= %.3f real= %.3f\n", 	\
+			theoric_maxval, real_maxv);
+#endif
+
+fimg_clear(dst);
+
+for (y=0; y<src->height; y++) {
+
+	for (x=0; x<src->width; x++)
+		{
+		fimg_get_rgb(src, x, y,  rgb);
+		rgb[0] = real_maxv * fabs(cos(21.0 * rgb[0] / real_maxv));
+		rgb[1] = real_maxv * fabs(cos(31.0 * rgb[1] / real_maxv));
+		rgb[2] = real_maxv * fabs(cos(11.0 * rgb[2] / real_maxv));
+		fimg_put_rgb(dst, x, y, rgb);
+		}
+	}
+
+return 0;
+}
 /* -------------------------------------------------------------- */
 /*
  *		please, add some parameters !
@@ -55,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;
@@ -65,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;
@@ -93,20 +179,36 @@ float		vals[3];
 fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
 #endif
 
-#define STP  16			/* stepd for x & y axex */
+/*	    XXX  CRITICAL BUG  XXX
+ *
+ *	what to do if STP is not a modulo of
+ *	the width (or size) of the picture ?
+ *	why if img height is 600 and stp was 16 ?
+
+     tth@redlady:~/Devel/FloatImg/Fonderie$ bc -l
+     600/16
+     37.50000000000000000000
+
+ *
+ *   And this mistake is all around the code /o\
+ *
+ */
+#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 */
 		pixel_trinitron(pimg, coo, vals);
 		}
 	}
 #undef STP
+
+// fprintf(stderr, "   end trinitron\n");		// XXX
+
 return 0;
 }
 /* -------------------------------------------------------------- */
@@ -338,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++) {

Fonderie/sfx.h

@@ -3,8 +3,11 @@
  *	---------------------------------------------------
  */
 
+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);
 

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

Fonderie/singlepass.c

@@ -13,6 +13,7 @@
 
 #include  "../floatimg.h"
 
+#include  "utilfuncs.h"
 #include  "crapulator.h"
 #include  "filterstack.h"
 #include  "single.h"
@@ -25,6 +26,9 @@
 int		verbosity;
 
 /* ----------------------------------------------------------- */
+/*
+ *	parameter 'duplic' is the repetition factor
+ */
 int run_the_singlepass(char *globber, char *destdir, int duplic,
 					int fchain, int outfmt)
 {
@@ -35,11 +39,11 @@ char		*fname;
 double		elapsed;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' '%s' %d %d )\n", __func__,
-				globber, destdir, fchain, outfmt);
+fprintf(stderr, ">>> %s ( '%s' '%s'  %d  %d %d )\n", __func__,
+				globber, destdir, duplic, fchain, outfmt);
 #endif
 
-// filterstack_list(fchain, "Run the single pass");
+if (verbosity) filterstack_list(fchain, "Run the single pass");
 
 (void)fimg_timer_set(0);
 
@@ -81,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) {
@@ -107,10 +115,6 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
 			fprintf(stderr, "error %d on push_picture\n", foo);
 			return foo;
 			}
-		if (loop) {
-			/* this is just a wip XXX */
-			microglitch(&image, loop);
-			}
 		}
 	}
 
@@ -119,7 +123,7 @@ fprintf(stderr, "\n");
 globfree(&globbuf);
 
 fimg_destroy(&image);
-single_print_state("end of run", 0);
+// single_print_state("end of run", 0);
 
 elapsed = fimg_timer_get(0);
 fprintf(stderr, "%s: %ld frames, elapsed %.3f s, %.3f fps\n",
@@ -156,9 +160,9 @@ char		*outdir      =   "./p8";
 int		do_xper = 0;
 int		repeat = 1;
 
-fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
+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]);
@@ -188,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) {
@@ -196,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);
@@ -212,9 +222,12 @@ if (verbosity) {
 	fprintf(stderr, "\tdo xper           %d\n", do_xper);
 	}
 
+/*
+ *		REAL action here
+ */
 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;
 }

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,24 +190,24 @@ 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("01137.fimg", &image);
+foo = fimg_create_from_dump(fname, &image);
 if (foo) {
 	fprintf(stderr, "%s: err %d on create_from_dump\n",
 			__func__, foo);
 	return -1;
 	}
 
-foo = fimg_clone(&image, &dest, 1);
-foo = fimg_copy_data(&image, &dest);
+foo = fimg_clone(&image, &dest, 0);
 
-incrustation_vignette(&image, &dest, 0);
+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) {

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 */
+}
+/* -------------------------------------------------------------- */
+

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);
+
+/* -------------------------------------------------------------- */

LICENSE

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

Makefile

@@ -3,8 +3,8 @@
 #          a look to the 'build.sh' script !       #
 ####################################################
 
-COPT = -Wall -Wextra -fpic -g -pg  -no-pie -DDEBUG_LEVEL=0
-LDOPT = libfloatimg.a -pg -lm 
+COPT = -Wall -Wextra -fpic -g  -no-pie -DDEBUG_LEVEL=0
+LDOPT = libfloatimg.a -g -lm 
 
 all:	essai
 
@@ -13,6 +13,9 @@ all:	essai
 essai:		essai.c libfloatimg.a floatimg.h Makefile
 	gcc $(COPT) $< $(LDOPT) -lpnglite -lz -o $@
 
+install:
+	@echo "=== Use the 'install.sh' script ==="
+
 #---------------------------------------------------------------
 
 TOTAR = *.[ch] Makefile *.sh *.md 			\

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,9 +49,18 @@ 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 libncurses-dev
 ```
 Il est probable que j'en oublie.
-Et ya Debian qui change des trucs, alors, ça marche plus
+Et ya Debian qui change des trucs, alors, ça marche plus, du
+genre que c'est la deuxième fois que ça m'arrive.
 
 ```
 E: Unable to locate package libv4l2-dev
@@ -53,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
 
@@ -63,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...*

build.sh

@@ -1,10 +1,12 @@
 #!/bin/bash
 
+set -e ; set -u
+
 # ------------------------------------------------------------------
 
 function build
 {
-echo ============= $1 ==============
+echo "============= $1 =============="
 curdir=${PWD}
 cd $1
 make 
@@ -13,7 +15,7 @@ cd ${curdir}
 
 if [ ${error} -ne 0 ]
 then
-	echo === error on $1 = ${error}
+	echo "=== error on $1 = ${error}"
 	exit 1
 fi
 }
@@ -28,7 +30,7 @@ build Fonderie
 
 # ------------------------------------------------------------------
 
-
+echo "========== Project root ==============="
 make
 
 # ------------------------------------------------------------------

contrib/.gitignore

@@ -0,0 +1,14 @@
+
+fimg2povhf
+demo_fmorph
+
+toto
+core
+
+*.tga
+*.png
+*.pnm
+*.gif
+*.fimg
+*.mp4
+

contrib/Makefile

@@ -1,7 +1,18 @@
 
-DBGL = '-DDEBUG_LEVEL=1 -g '
+DBGL = -DDEBUG_LEVEL=1 -g
 
 fimg2povhf:	fimg2povhf.c Makefile
 	gcc -Wall $(DBGL) $< -limage -lfloatimg -lm -o $@
 
+# --------------------------------------------------------
 
+demo_fmorph:	demo_fmorph.c Makefile
+	gcc -Wall $(DBGL) $< -lfloatimg -lpnglite -lm -o $@
+
+in.fimg:	Makefile
+	mkfimg -t tpat0 -v $@ 640 480 
+
+out.png:	in.fimg demo_fmorph
+	./demo_fmorph $< $@
+
+# --------------------------------------------------------

contrib/README.md

@@ -4,9 +4,11 @@
 
 Need some external garbage, sorry.
 
-Try to compile this really old code:
-   http://la.buvette.org/devel/libimage/libimage.html
+## do_eff_spass.sh
+
+Script shell permettant (en théorie) de faire un montage
+d'une petite séquence de chacun des effets disponibles
+dans la Fonderie. `singlepass` inside.
 
-Use the code, frtk !
 
 

contrib/demo_fmorph.c

@@ -0,0 +1,116 @@
+/*
+ *		DEMONSTRATOR FOR FMORPHO
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+
+#include  <floatimg.h>
+
+int		verbosity = 1;
+
+#define    DF_W   512
+#define    DF_H   128
+
+/* ~~~ -------------------------------------------------------------- +++ */
+int demo_fmorph(char *srcf, char *dsti, int mode)
+{
+FloatImg		simg, 		// image source
+			timg, uimg,	// intermediaires
+			dimg;		// destination
+FimgArea51		rect;
+char			line[200];
+
+int			foo, pass, hpos;
+
+fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__, srcf, dsti, mode);
+
+/*
+ *	chargement image source
+ */
+foo = fimg_create_from_dump(srcf, &simg);
+fprintf(stderr, "    load of %s --> %d\n", srcf, foo);
+if (foo) {
+	return foo;
+	}
+
+/*
+ *	images temporaires
+ */
+foo = fimg_create(&timg, DF_W, DF_H, FIMG_TYPE_RGB);
+if (foo) {
+	fprintf(stderr, "err %d create T img\n", foo);
+	return foo;
+	}
+foo = fimg_create(&uimg, DF_W, DF_H, FIMG_TYPE_RGB);
+if (foo) {
+	fprintf(stderr, "err %d create U img\n", foo);
+	return foo;
+	}
+
+/*
+ *	image de destination
+ */
+foo = fimg_create(&dimg, DF_W, DF_H*9, FIMG_TYPE_RGB);
+if (foo) {
+	fprintf(stderr, "err %d create D img\n", foo);
+	return foo;
+	}
+
+/*
+ *	this is an iterator 
+ */
+rect.x = 20;		rect.y = 20;
+rect.w = DF_W;		rect.h = DF_H;
+
+for (pass=0; pass<9; pass++) {
+	hpos = pass * DF_H;
+	fprintf(stderr, "pass %d, hpos %d\n", pass, hpos);
+	foo = fimg_extractor(&simg, &timg, &rect);
+
+	// sprintf(line, "S_%02d.png", pass);
+	// foo = fimg_save_as_png(&timg, line, 0);
+
+	foo = fimg_filtre_morpho_0(&timg, &uimg, pass);
+	if (foo) {
+		fprintf(stderr, "err %d filtre morpho, pass %d\n", 
+					foo,			pass);
+		exit(1);
+		}
+	sprintf(line, "D_%02d.png", pass);
+	foo = fimg_save_as_png(&uimg, line, 0);
+
+	foo = fimg_incrustator_0(&uimg, &dimg, 0, hpos, 0);
+	if (foo) {
+		fprintf(stderr, "err %d incrustator\n", foo);
+		exit(1);
+		}
+	}
+
+foo = fimg_save_as_png(&dimg, dsti, 0);
+/*
+ *	do some cleanup
+ */
+fimg_destroy(&simg); fimg_destroy(&timg); fimg_destroy(&dimg);
+
+
+return 0;
+}
+/* ~~~ -------------------------------------------------------------- +++ */
+int main(int argc, char *argv[])
+{
+int		foo;
+
+fimg_print_version(1);
+
+if (3 != argc) {
+	fprintf(stderr, "usage:\n\t%s src.fimg dst.png\n", argv[0]);
+	exit(1);
+	}
+
+foo = demo_fmorph(argv[1], argv[2], 0);
+fprintf(stderr, "    got --> %d\n", foo);
+
+return 0;
+}
+/* ~~~ -------------------------------------------------------------- +++ */

contrib/do_eff_spass.sh

@@ -0,0 +1,163 @@
+#!/bin/bash
+
+set -e
+
+SPASS="../Fonderie/singlepass"
+
+SRCDIR=$HOME"/Essais/PS-eye/frames/"
+DSTPOL=$HOME"/TMP/"
+echo "source   = " $SRCDIR
+echo "spool    = " $DSTPOL
+
+LINKFARM=$DSTPOL"LinkFarm"
+echo "linkfarm = " $LINKFARM
+
+# VIDZ="$HOME/BU/vrac/all_effects.mp4"
+VIDZ="foo.mp4"
+echo "lolvidz  = " $VIDZ
+
+LINKNUM=0
+
+#	--------------------------------------------
+
+do_an_effect_pass()
+{
+local effect=$1
+local ddir=$2
+
+figlet "$effect" ; echo
+echo "  files to ===> " $ddir
+
+rm -f    $ddir/?????.png
+
+$SPASS  -F $effect 				\
+	-g $SRCDIR/'?????.fimg'			\
+	-O $ddir				\
+	-r 1
+
+}
+
+#	--------------------------------------------
+insert_blank()
+{
+local count=$1
+
+local imgname="$DSTPOL/blank.fimg"
+
+if [ ! -r $imgname ] ; then
+	mkfimg -v -t black $imgname 640 480
+	fimg2png -v $imgname $DSTPOL/blank.png
+	echo "blankimage done" | boxes
+	# display $DSTPOL/blank.png &
+	# exit
+fi
+
+for foo in $(seq 0 $count)
+do
+	linkname=$(printf "%s/L%05d.png" $LINKFARM $LINKNUM)
+	ln --force --symbolic $DSTPOL/blank.png $linkname
+	# file $linkname
+	LINKNUM=$(( LINKNUM + 1 ))
+done	
+}
+#	--------------------------------------------
+
+make_the_linkfarm_from()
+{
+local effname=$1
+local sdir=$2
+
+echo	"====== Linkfarming from " $sdir 		\
+	"====== avec" $(ls $sdir | wc -l) "images"
+
+mogrify							\
+	-font Utopia-Bold				\
+	-pointsize 64					\
+	-kerning 9					\
+	-fill Gray90					\
+	-stroke Gray10					\
+	-strokewidth 2					\
+	-gravity South-East				\
+	-annotate +30+20 $effname			\
+	$sdir/*.png
+
+for img in $(ls -1 $sdir/?????.png)
+do
+	
+	linkname=$(printf "%s/L%05d.png" $LINKFARM $LINKNUM)
+	# echo "image = " $img 
+	# echo "link  = " $linkname
+
+	ln --force --symbolic $img $linkname
+
+	LINKNUM=$(( LINKNUM + 1 ))
+done
+echo "          linkfarming done"
+}
+#	--------------------------------------------
+#		traite tous les effets
+
+do_all_the_effects()
+{
+EFFECTS=$( $SPASS -L | sort )
+
+banner 'FULL RUN'
+
+for effect in $EFFECTS
+do
+	DDIR=$DSTPOL"/$effect"
+
+	if [ -d $DDIR ] ; then
+		rm -f $DDIR"/?????.png"
+	fi
+	if [ ! -r $DDIR ] ; then
+		mkdir -v $DDIR
+	fi
+
+	do_an_effect_pass $effect $DDIR
+	make_the_linkfarm_from $effect $DDIR
+
+	insert_blank 30
+done
+}
+
+#	--------------------------------------------
+
+debug_run()
+{
+local eff=$1
+local DDIR=$DSTPOL"/$eff"
+
+banner 'DEBUG RUN'
+echo "DDIR = " $DDIR
+
+do_an_effect_pass       $eff  $DDIR
+make_the_linkfarm_from  $eff  $DDIR
+}
+
+#	--------------------------------------------
+#			MAIN
+
+echo 
+
+rm -v -f $LINKFARM/L*.png ; echo
+
+insert_blank 30
+
+# debug_run 'rndblks'
+do_all_the_effects
+
+banner 'encoding'
+
+ffmpeg  -nostdin                                                \
+	-loglevel   warning					\
+        -y -r 30 -f image2 -i ${LINKFARM}/L%05d.png		\
+	-metadata artist='---[ tTh ]---'			\
+	-metadata title='---[ All the 'Fonderie' effects ]---'	\
+ 	-preset veryslow					\
+        -c:v libx264 -pix_fmt yuv420p                            \
+        $VIDZ
+
+echo "   encoding of " $VIDZ " . . . . . [done]"
+
+

doc/the_floatimg_hack.tex

@@ -10,7 +10,7 @@
 
 % \lstset{frame=single}           % dessin d'un cadre autour du listing
 \lstset{basicstyle=\ttfamily\small}
-\lstset{aboveskip=0.1em,belowskip=0.1em}
+\lstset{aboveskip=0.01em,belowskip=0.1em}
 
 \usepackage{babel}			% ?
 
@@ -25,8 +25,10 @@
 % \usepackage{url}
 \usepackage{xspace}
 \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 ?
@@ -41,7 +43,7 @@
 \makeindex
 
 % ------ a few new commands
-\newcommand{\interparagraphe { \vspace{60pt} } }
+\newcommand{\interparagraphe { \vspace{50pt} } }
 
 % -------------------------------------------------------------------
 \title{Floating images processing (for fun and profit ?)}
@@ -52,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},
@@ -77,7 +79,13 @@ pour ceux qui suivent le canal \texttt{\#tetalab} sur le réseau
 IRC de \textsl{libera.chat}.
 
 \textbf{Attention !} ce document commence par une bonne rafale
-de technique parfois \textsl{hardue}, avec des pointeurs dedans.
+de technique parfois \textsl{hardue}\footnote{hard + ardue = private
+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.
 
@@ -92,7 +100,7 @@ certains points. Je vais tenter de répondre à ces FAQ~:%
 « Fréquentes et Absurdes Questions » avec des réponses
 absurdes et précises.
 
-\subsubsection*{c'est quoi un image d'un point de vue physique ?}
+\subsubsection*{c'est quoi une image d'un point de vue physique ?}
 
 Une représentation approximative d'un monde physique invisible.
 L'infinie bio-complexité de notre système oculaire et ses interactions
@@ -102,8 +110,9 @@ 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.
-Ah, les pointeurs, la pire chose du monde\dots
+\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}
 
@@ -122,13 +131,13 @@ dans les machin-trocs, et un grain d'image vraiment présent.
 
 Ah vous en voulez de la technique ? Oké, on y va.
 En fait, on va tripoter pleins de nombres, plus ou moins rangés dans
-des champs de pixels, pour concrétiser l'existence perceptuelles de ces
+des champs de pixels, pour concrétiser l'existence perceptuelle de ces
 grains de lumière chromatisés.
 
 \subsubsection*{quelques belles images / schémas polychromes en intro pour 
 			illustrer tout ça}
 
-Tour cela est dans le grand Ternet\footnote{\textsl{Thanks, mister J Postel}}
+Tour cela est dans le grand Ternet
 mondial, je pourrais même vous donner l'url si vous me promettez de ne pas
 la glisser dans le capitalisme de surveillance.
 
@@ -136,20 +145,23 @@ la glisser dans le capitalisme de surveillance.
 
 \setlength \parskip {0em}
 
+\pagebreak
 \tableofcontents
 \pagebreak
 \setlength \parskip {0.40em}
 
-\layout \pagebreak
+% XXX \layout \pagebreak
 
 % ===================================================================
-\section{Théorie}\index{théorie}
 
+\section{Théorie}\index{théorie}
 
 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
@@ -164,22 +176,36 @@ 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
 
 \subsection{Dynamique}\index{dynamique}
 
 Dynamique, précision et \textsl{macheps} ? Peu de gens connaissent
 la fourbitude des calculs en virgule flottante avec les ordinateurs.
-Moi-même compris.
+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
 si nous songeons à des coefficients d'absorption, ou un canal
-\textsl{alpha} qui inverserait les valeurs ? 
+\textsl{alpha} qui inverserait les valeurs ? Un domaine dont
+l'exploration peut confiner au mysticisme de part la multitude
+des traitement possibles : valeur absolue, \textsl{clamping},
+report sur les autres composantes. Votre imagination est
+la limite.
 
 % ===================================================================
 
@@ -192,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}
 
@@ -200,8 +226,8 @@ Pour commencer par quelque chose de simple,
 nous allons créer une image RGB\index{RGB} complètement noire,
 puis l'enregistrer dans un fichier \texttt{.fimg}\index{.fimg},
 un format complètement inconnu, puisque je viens de l'inventer
-à l'instant même.
-Enfin, non, il y a déja longtemps, avant la grande pandémie.
+à l'instant même\footnote{Enfin, non, il y a déja longtemps,
+avant la grande pandémie.}.
 
 Tout d'abord, nous devons déclarer et garnir quelques variables
 pour gérer la machinerie interne.
@@ -216,8 +242,9 @@ Ensuite, nous enchainerons trois étapes : la création de l'image
 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 dans un fichier\footnote{Au format
-ésotérique, mais très véloce.} binaire.
+et pour conclure, l'enregistrement de cette image dans un
+fichier\footnote{Au format ésotérique, mais très véloce.}
+binaire.
 
 \begin{lstlisting}
 memset(fimg, 0, sizeof(FloatImg));
@@ -234,10 +261,9 @@ if (foo) {
         }
 \end{lstlisting}
 
-
-Une fois ce code enrobé dans un \texttt{main()}, compilé et exécuté,
+Une fois ce code enrobé dans un \texttt{main()}, compilé puis exécuté,
 nous pouvons entrevoir, grâce au logiciel
-\texttt{fimgstats} (voir page \pageref{fimgstats}),
+\texttt{fimgstats} (décrit en page \pageref{fimgstats}),
 le résultat sous forme de chiffres divers, et/ou inutiles~:
 
 \begin{verbatim}
@@ -261,9 +287,9 @@ Avec un bon script bash, il y a déja de quoi faire.
 La suite vers la page \pageref{codaz}. 
 
 Vous trouverez dans le répertoire \texttt{tools/}\index{tools/}
-d'autres exemples de mise en œuvre des fonctions disponibles
+d'autres exemples de mise en œuvre de quelques fonctions disponibles
 sous formes d'outils en ligne de commande,
-lesquels sont approximativement décrits en page \pageref{outils}.
+lesquels outils sont approximativement décrits en page \pageref{outils}.
 
 % ===================================================================
 \section{Installation}
@@ -273,21 +299,22 @@ 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}
 
 Vous devez, en dehors des outils classiques (gcc, Awk, make\dots), 
-avoir quelques bibliothèques installées\footnote{Les \texttt{-dev}
-en plus pour Debian et dérivées}~:
+avoir quelques bibliothèques installées~:
 \textsf{
 libv4l2, libpnglite, libtiff,
 libnetpbm\footnote{package libnetpbm10-dev},
 libz\footnote{package zlib1g-dev}, libcurses,
-libcfitsio-dev
+libcfitsio...
 } % end of textsf
-éventuellement avec le \textsf{-dev} correspondant,
+éventuellement avec le \textsf{-dev} correspondant, qui contient, entre
+autres, les fichiers \texttt{.h} associés
 et probablement d'autres choses.
 
 Il est même quasiment certain que Bash soit indispensable, tout
@@ -296,7 +323,8 @@ Une connaissance de base de l'utilisation du shell\index{shell}
 et de l'écriture de Makefile's sera un plus.
 
 Il faut aussi savoir où trouver le code. Il est dans le Git du
-Tetalab. Mais comme je ne comprend rien à Git, c'est pas la peine
+Tetalab\footnote{\texttt{https://git.tetalab.org/tTh/FloatImg}}.
+Mais comme je ne comprend rien à Git, c'est pas la peine
 de m'envoyer des trucs genre \textsl{pull-request} auquels je ne
 comprend rien.
 
@@ -338,7 +366,7 @@ Faites-en ce que vous voulez.
 Classiquement, il y a un fichier \texttt{.h} à inclure dans chacun
 de vos codes source,
 \texttt{floatimg.h}, généralement logé dans \texttt{/usr/local/include}
-contenant un certain nombre de définition de structures, de macros, 
+et contenant un certain nombre de définition de structures, de macros, 
 de constantes\footnote{À l'ancienne, via le pré-processeur} 
 et les prototypes des fonctions utilisables par vos logiciels.
 
@@ -347,7 +375,7 @@ classées en deux catégories : \texttt{lib/} et \texttt{funcs/}.
 La première contient les choses qui sont relativement figées,
 et la seconde celles qui risquent de bouger. Cette classification
 est en fait indécement arbitraire.
-D'autant plus qu'il y a aussi un répertoire nommé « experiemental ».
+D'autant plus qu'il y a aussi un répertoire nommé « experimental ».
 
 \subsection{Structures, macros\dots}
 
@@ -406,7 +434,7 @@ quelques images...
 
 Le champ \textsl{count} sera mis à 0 et 
 le champ \textsl{fval} sera initialisé à 15.0
-(qui est la valeur maximale que peut renvoyer ce capteur).
+(ce qui est la valeur maximale que peut renvoyer ce capteur).
 Ensuite, dans la boucle capture/cumul, \textsl{count} sera
 incrémenté à chaque passe, et nous aurons donc, en finale, 
 toutes les informations nécessaires pour exploiter au mieux la dynamique
@@ -445,24 +473,26 @@ avant le moindre usage\footnote{\texttt{man 3 memset}}.
 Certains membres de cette structure sont
 documentés dans ce document, et les autres sont dangereux à
 toucher. Les types d'images actuellement gérés sont les trois grands
-classiques : gray, rgb et rgba.  et expliquées quelques lignes plus haut.
+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: une source et une destination.
-Et dans la plupart des cas, ces deux images doivent être compatibles,
-c'est à dire même type et mêmes dimensions.
+prennent en argument deux images: la source et la destination.
+Dans la plupart des cas, ces deux images doivent être compatibles,
+c'est à dire de même type et de mêmes dimensions.
 
 \begin{lstlisting}
-/* return 0 if compatible */
+/* 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.
 Il y a deux opérations qui supportent le reste des transits ram/ps.
-Le format des fichiers est décrit page \pageref{formatfimg}.
+Le format de ces fichiers est décrit page \pageref{formatfimg}.
 
 \begin{lstlisting}
 int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused);
@@ -472,7 +502,7 @@ int fimg_load_from_dump(char *fname, FloatImg *where);
 Recharger une image depuis un fichier nécessite que celle-ci et
 l'image de destination en mémoire 
 ait précisément les mêmes caractéristiques
-(taille, type...), donc l'image en ram doit être
+(taille, type...), donc l'image en mémoire centrale doit être
 pré-allouée. On peut connaitre ces valeurs en appelant
 \texttt{int fimg\_fileinfos(char *fname, int datas[3])}.
 
@@ -497,17 +527,20 @@ foo = fimg_create_from_dump("lena.fimg", &head);
 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\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
@@ -526,7 +559,8 @@ $x$ et $y$ de la demande.
 Quand au canal \textsl{alpha}\index{alpha}, il est pour le moment
 superbement ignoré. Ceci dit, on vient de me faire remarquer qu'il
 peut être utilisable aussi pour faire du
-\textsl{z-buffer}\index{z-buffer}\index{rgbz}\dots
+\textsl{z-buffer}\index{z-buffer}\index{rgbz}, une technique
+classique dans la génération d'images en trois dimensions.\dots
 
 %		----------------------------------
 
@@ -644,7 +678,12 @@ aux bonnes dimensions (échange W et H).
 \subsection{Format du fichier \textsc{fimg}}\index{format}\label{formatfimg}
 
 D'un design très empirique, c'est certainement à revoir pour l'avenir.
-Tout d'abord pour normaliser l'endianess et le packing\dots
+La force du \textsl{legacy} va-t-elle dominer le monde ?
+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. Nous appelerons ça les metadonnées, et
+nous en parlons dans quelques pages.\dots
 
 \begin{lstlisting}
 typedef struct {
@@ -653,23 +692,60 @@ typedef struct {
 	} FimgFileHead;
 \end{lstlisting}
 
-\dots Mais aussi pour faciliter l'ajout de métadonnées, telles que
-la valeur maximale, la date de création, une longueur d'onde,
-et bien plus encore.
 
 Le champ \texttt{magic[8]} doit contenir une valeur magique~:
-les quatre premier octets doivent contenir les quatre caractères
-\texttt{'FIMG'}, et les quatre dernier doivent être à 0.
+les quatre premiers octets doivent contenir les quatre caractères
+\texttt{'FIMG'}, et les quatre derniers doivent être à 0, sauf que,
+voir plus bas, le cinquième vas vous étonner.
 Le champ \texttt{t} (le type de l'image) doit avoir les trois octets
-de poids fort à 0. Vous trouverez les constantes de type dans le
+de poids fort à 0\footnote{Pourquoi ? Je n'en sais rien.}.
+
+Ensuite, nous aurons (dans le cas courant) : 1, 2 ou 4 blocs
+de WxH pixels sous forme de Float32. La première ligne lue
+est la ligne du haut de l'image. Les valeurs négatives sont
+tolérées.
+
+Vous trouverez les constantes de type pertinentes dans le
 fichier \texttt{floatimg.h}, et quelques informations
-(non-)essentielles qui ne vous servirons probablement à rien.
+(non-)essentielles qui ne vous serviront probablement à rien.
+
+
+%		----------------------------------
+% new février 2022
+
+\subsection{Métadonnées}
+\index{metadata} \index{timestamp}
+
+Attention, ce n'est pas encore une version définitive, beaucoup de
+choses restent à préciser sur le contenu de cette structure, mais
+l'essentiel est déja là. On reconnait un fichier avec metadata
+quand l'octet \texttt{magic[4]} du premier header est égal à
+la lettre \texttt{'a'}.
+
+\begin{lstlisting}
+typedef struct {
+	char		magic[8];
+	struct timeval	timestamp;
+	int32_t		count;
+	float		fval;
+	char		idcam[32];
+	int32_t		origin;			// enum ?
+	} FimgMetaData;
+\end{lstlisting}
+
+Voyons maintenant chacun des champs de cette structure, en prenant bien
+en compte qu'à ce moment\footnote{4 avril 2022}, tout n'est pas figé.
+Ceci dit, nous allons aussi retrouver de vieilles connaissances.
+
+\textbf{to be continued}
 
 %		----------------------------------
 
 \subsection{Exportation \& Importation}\index{export}\label{export}
 
-Notre format de fichier étant totalement inconnu, il nous
+Notre format de fichier étant totalement inconnu%
+\footnote{Du monde extérieur, vous l'aurez compris.},
+il nous
 faut bien exporter nos images en quelque chose de plus
 connu. Bien entendu, c'est toujours affaire de compromis
 entre précision de valeurs et taille des fichiers.
@@ -678,7 +754,7 @@ Et dans le sens inverse, il serait bien de savoir importer
 le monde extérieur dans nos sombres caves à pixel.
 Il faut quand même reconnaitre que c'est un peu la jungle dans les
 formats de fichiers d'image, ce qui explique le retard
-dans ce domaine\dots 
+du développement dans ce domaine\dots 
 
 \subsubsection{Vers PNM}\index{PNM}
 
@@ -708,12 +784,14 @@ Les autres bits ne sont pas utilisés et doivent être à zéro.
 
 \subsubsection{Vers PNG}\index{PNG}
 
-Actuellement, on peut enregistrer uniquement en mode RGB,
-8 bits par composante,
+Actuellement, on ne peut enregistrer qu'en mode RGB uniquement,
+avec 8 bits par composante,
 mais on a quand même une bonne compression, ça compense.
+
 J'utilise \textsl{libpnglite} avec qui j'ai un peu de mal à suivre.
 Mais je me soigne. Le mode 16 bits va bientôt arriver.
-On peut aussi songer à l'export de    metadatas.
+On peut aussi songer à l'export des metadonnées, pour celles qui
+sont compatibles avec le standard PNG.
 
 \begin{lstlisting}
 int fimg_save_as_png(FloatImg *src, char *outname, int flags);
@@ -721,8 +799,9 @@ int fimg_save_as_png(FloatImg *src, char *outname, int flags);
 
 Tous les flags doivent être à zéro. Sinon, ça foire parfois.
 Et en fait (mars 2021) je ne suis pas très content de 
-\texttt{pnglite}, donc un de ces jours\footnote{Rendez-nous notre
-Mixou !}, je prendrais cinq jours pour régler le souci.
+\texttt{pnglite}, donc un de ces jours, je prendrais
+\sout{cinq} quelques jours pour
+régler ce souci en passant à la bibliothèque canonique.
 
 \subsubsection{Vers TIFF}\index{TIFF}
 
@@ -735,7 +814,7 @@ int fimg_write_as_tiff(FloatImg *src, char *outname, int flags);
 \end{lstlisting}
 
 Tous les flags doivent être à zéro. Pour le moment.
-
+Un premier jet pas forcément parfait.
 
 \subsubsection{Vers FITS}\index{FITS}
 
@@ -755,6 +834,7 @@ sais pas encore comment régler ce petit détail.
 
 Tous les flags doivent être à zéro.
 
+% =============================================================
 
 \subsection{Utilitaires}
 
@@ -767,17 +847,19 @@ fichier de configuration.
 int parse_WxH(char *str, int *pw, int *ph)
 int parse_double(char *str, double *dptr)
 \end{lstlisting}
-
+% XXX rjouter quelques explication, please !
 
 La fonction \texttt{int format\_from\_extension(char *fname)} examine un
 nom de fichier tel que \texttt{lena.xxx}, et retourne, si la partie
 \texttt{xxx} est connue, un éventuel nombre positif, dont les valeurs sont
 déclarées dans floatimg.h
 le valeureux.
-Les extensions actuellement connues sont : fimg, png, pnm, fits et tiff.
+Les extensions actuellement connues sont :
+fimg, png, pnm, pgm, fits et tiff. Le bmp est plus ou moins prévu\dots
 
 To be continued\index{XXX}\dots
 
+% =============================================================
 
 \subsection{Effets}\index{sfx}
 
@@ -801,10 +883,9 @@ J'ai commencé à étudier ces objets étranges quand j'ai commencé
 à travailler sur l'interpolator\index{interpolator} à l'automne 2020.
 Hélas, j'ai vite réalisé que c'était assez délicat.
 Pour ce genre de \textsl{usecase}, le numérique est pitoyable si on
-le compare au \textsc{Betamax}\index{Betamax}.
-
-%		----------------------------------
+le compare au (hélas défunt) \textsc{Betamax}\index{Betamax}.
 
+% =============================================================
 
 \subsection{Filtrages}\index{filtrage}
 
@@ -845,8 +926,10 @@ int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
 \end{lstlisting}
 
 Comme dans la plupart des cas, la gestion des valeurs négatives
-de pixel est laissé au hasard. Quoique, il doit bien exister
-quelques solutions de contournement : clamping ou shift ?
+de pixel est laissé au hasard, qui fait souvent du portnawak.
+Quoique, il doit bien exister
+quelques solutions de contournement :
+valeur absolue, clamping ou shiftup ?
 
 \textsl{To be continued\index{XXX}\dots}
 
@@ -859,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
@@ -897,19 +980,23 @@ En particulier tout le reste du code qui suppose qu'un pixel
 ne peut \textbf{pas} être négatif va peut-être exploser de rire.
 Vous pouvez aussi remarquer qu'il n'y a pas de controle
 de cohérence sur les dimensions des deux images, malgré l'existence
-de fonctions prévues à cet effet\dots
+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.
+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.
@@ -938,7 +1025,7 @@ deux nombres séparés ou la notation \texttt{WIDTHxHEIGHT}.
 
 La plupart des types d'image générée prennent un paramètre flottant qui
 devra être donné avec l'option \texttt{-k F.F} avec une valeur par défaut
-à $1.0$, ce qui n'est pas toujours une bonne valeur.
+à $1.0$, ce qui n'est pas toujours une bonne valeur, ymmv\index{ymmv}.
 
 \begin{description}	\index{XXX}
 \item [black/gray/grey:] efface avec 0.0 (black) ou avec la valeur
@@ -959,7 +1046,11 @@ error in 'fimg_create_from_png' : read png -> -1 File error
 png2fimg : err -1, abort.
 \end{verbatim}
 
-Il faut peut-être envisager le passage à \texttt{libpng}\index{libpng}.
+Il faut peut-être envisager le passage à \texttt{libpng}\index{libpng},
+la bibliothèque actuellement utilisée (\texttt{pnglite}) ayant tendance
+à borker en lecture sur certains fichiers pourtant corrects.
+
+%		---------------------
 
 \subsection{fimgstats}\index{fimgstats}\label{fimgstats}
 
@@ -1009,7 +1100,9 @@ sera lisible avec le sélecteur \texttt{-L}.
 
 Et pour les aventureux, la commande \texttt{xper} (abréviation
 de \textsl{expérimental}) permet de tester la plus récente tentative
-de friture du moment.
+de friture du moment. D'autre part un set bien plus complet d'effets
+àlc est disponible dans les logiciels de flou temporel, décrits
+plus loin dans ce document.
 
 %		---------------------
 
@@ -1043,6 +1136,9 @@ La véracité mathématique n'est pas garantie. Et n'oubliez pas que
 les valeurs négatives peuvent être la cause de \textsl{glitches}
 de qualitay.
 
+La liste des opérations est susceptible d'être agrémenté de quelques
+possibilités bien féroces\footnote{Stay tuned, flim at 11.}.
+
 %		-------------------------
 
 \subsection{fimg2png, fimg2pnm, fimg2tiff, fimg2fits}
@@ -1110,12 +1206,13 @@ tth@fubar:~/Devel/FloatImg/doc$ fimg2text -s 1 quux.fimg
 tth@fubar:~/Devel/FloatImg/doc$ 
 \end{verbatim}
 
-Et maintenant, vous voulez un gros exemple ?
+Et maintenant, vous voulez un gros exemple ? Bah, ça doit demander
+l'utilisation de Povray\index{Povray}.
 
 
 %		-------------------------
 
-
+%   beaucoup trop de maths approximative dans ce passage.
 
 \subsection{fimg2gray}\index{fimg2gray}\label{fimg2gray}
 
@@ -1138,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} ?}
 
@@ -1210,7 +1308,7 @@ if (foo) {
 \end{verbatim}
 
 À condition d'avoir bien réglé votre ulimit pour la génération d'un coredump,
-vous aurez sous la main un fichier \textsc{core} qui vous permettra
+vous aurez sous la main un fichier \texttt{core} qui vous permettra
 de, par exemple, remonter la pile d'appel avec la commande \texttt{back} de
 gdb. Mais pour le moment, juste une infime partie du code est instrumentée
 avec ce dispositif.
@@ -1232,7 +1330,7 @@ Il reste plein de choses à faire pour que ce soit vraiment utilisable,
 surtout dans un contexte artistique à grande porosité.
 C'est par ces frottements de techniques ayant du sens que les
 choses seront acquises, pour le pire, le meilleur et la
-futilité du monde futur..
+techno-futilité du monde futur..
 
 \begin{itemize} 
 \item	Import/export au format \textsc{tiff}\index{TIFF} à continuer.
@@ -1242,7 +1340,7 @@ futilité du monde futur..
 \item	Formaliser les codes d'erreur. \textbf{Urgent}.
 \item	Faire une passe complète de Valgrind\index{valgrind}.
 \item	Intégrer la fonderie, l'interpolator et le singlepass.
-\item	Vérifier le gestion des images mono-canal.
+\item	Vérifier le gestion des images mono-canal et de la transparence.
 \end{itemize}
 
 % ===================================================================
@@ -1256,7 +1354,7 @@ jamais négliger le traitement des éventuelles erreurs.
 Nous savons générer une image contenant des pixels aux valeurs
 probablement aléatoires, avec la commande \texttt{mkfimg},
 qui utilise le \texttt{drand48}\index{drand48} de \textsc{posix}\index{POSIX}.
-Maintenant, posons-nous une question de statisticien : ue se passe-t-il si 
+Maintenant, posons-nous une question de statisticien : que se passe-t-il si 
 nous faisons la somme de plusieurs centaines de ces images ?
 
 \begin{lstlisting}
@@ -1323,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.
 
@@ -1344,10 +1442,12 @@ OFFS=$(( NBRE / 4 ))
 \end{verbatim}
 
 
-Dans ce préliminaire logiciel, nous avons nommés le répertoire
+Dans ce préliminaire logiciel, nous avons nommé le répertoire
 \textsc{srcdir} contenant les captures d'image au format fimg, le répertoire
 \textsc{dstdir} dans lequel seront rangées les images calculées,
-et l'emplacement de deux fichiers de travail.
+et l'emplacement de deux fichiers de travail, placés dans ce qui
+peut être vu comme un \textsl{ramdisk}\index{ramdisk}\index{/dev/shm/}
+et qui accélère un peu les opérations.
 
 Les quelques lignes suivantes, qui semble bien magiques, ne sont en fait
 que de la magie Unix\index{Unix}. Elles nous permettent d'avoir
@@ -1393,12 +1493,12 @@ $sin(idx/16)$ afin d'avoir une oscillation du coefficient entre
 \begin{verbatim}
         #        do the hard floating computation
         #
-        fimgfx  -v cos010 ${imgB} ${FTMP}
-        fimgops    -k ${K} ${FTMP} ${imgA} mix ${FDST}
+        fimgfx   -v cos010 ${imgB} ${FTMP}
+        fimgops  -k ${K} ${FTMP} ${imgA} mix ${FDST}
 \end{verbatim}
 
 Étape suivante, étape cruciale : le brassage d'une multitude de
-pixels flottants.
+pixels flottants. 
 
 Tout d'abord, nous faisons subir à l'image-echo
 (\texttt{imgB}, définie au début du script) un distorsion
@@ -1416,8 +1516,8 @@ done
 \end{verbatim}
 
 Et en fin de boucle, nous convertissons le résultat de nos
-savants calculs au format PNG, et écrivons le fichier dans le répertoire
-de destination fixé au début. 
+savants calculs au format PNG, et nous écrivons le fichier dans le
+répertoire de destination fixé au début. 
 C'est le moment de passer la main à ffmpeg\index{ffmpeg}.
 
 C'est juste une POC\index{POC}, et une implémentation bien plus
@@ -1425,6 +1525,9 @@ complète écrite en \textbf{C}\index{C} est déja en chantier,
 avec une complexité prévue à un niveau assez réjouissant.
 
 % ===================================================================
+%
+%	V4L2 is a trap.
+%
 \section{Video for Linux}\index{v4l2}
 
 Donc, maintenant, nous savons un peu tripoter ces images flottantes.
@@ -1440,11 +1543,11 @@ v4l2.
 
 \subsection{grabvidseq}\index{grabvidseq}\label{grabvidseq}
 
-Un logiciel en évolution (trop ?) lente, qui permet déja la capture
-d'images en
+Un logiciel en évolution (vraiment trop) lente, qui permet déja
+la capture d'images en
 \textsl{longue pose} selon la méthode du cumul\index{cumul}, et
 devrait bientôt retrouver sa capacité à enregistrer des
-séquences d'images.
+séquences d'images. (\textsl{workaround}~: écrire une boucle en shell)
 
 \begin{verbatim}
 tth@debian:~/Devel/FloatImg/v4l2$ ./grabvidseq -h
@@ -1480,8 +1583,8 @@ vaguement expliqué page \pageref{contraste}.
 
 L'option \texttt{-X} me permet d'intégrer des \textit{fritures}
 expérimentales dans le binaire, et ne doit donc pas être
-utilisée dans des scripts si on a des visions à long (ou même)
-terme.
+utilisée dans des scripts si on a des visions à long
+(ou même moyen) terme.
 
 \subsubsection{Upscaling}\index{upscaling}\label{upscaling}
 
@@ -1515,19 +1618,30 @@ Options :
 Je me sens obligé d'avouer qu'il reste quelques points mystérieux dans
 l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
 ce logiciel doit être pris avec des pincettes. En particulier
-la liste des résolutions disponibles.
+des choses essentielles comme la liste des résolutions disponibles.
 
 \subsection{nc-camcontrol}
 
 Ajustement \textsl{Brightness Contrast Saturation Hue\dots}
 
+Probablement pilotable au joystick\index{joystick} et surtout
+par OSC (Open Sound Control).
+
 % ===================================================================
 \section{À l'extérieur}
 
+Il existe une foultitude de logiciels (composants ou end-yuser) et
+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}
 
-Pour afficher notre format .fimg exotique avec \texttt{display}, vous
+Pour afficher notre format .fimg exotique avec \texttt{display}, un
+des éléments du package ImageMagick, vous
 devez mettre ce bout de XML\index{XML} dans le fichier
 \texttt{\$HOME/.magick/delegates.xml}~:
 
@@ -1539,17 +1653,20 @@ 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\dots
-Je compte donc sur le bouquin de \textsl{Brunus} pour avancer\dots
+résultat de la conversion.
+Je compte donc sur le bouquin de \textsl{Brunus}\index{Brunus}
+pour avancer\dots
 
 \subsection{Gimp}\index{Gimp}
 
 Mmmmm... Ça semble un peu plus compliqué.
 La documentation à ce sujet me semble ésotérique.
 D'un autre coté, il
-faut faire ça en \textbf{C}, ce qui ne peut pas être négatif.
+faut faire ça en \textbf{C}, ce qui ne peut pas être totalement négatif.
+Sauf pour les riiRistes.
 
 \subsection{ffmpeg}\index{ffmpeg}
 
@@ -1562,61 +1679,182 @@ ffmpeg  -nostdin                                \
         -c:v libx264                            \
         -pix_fmt yuv420p                        \
         -tune film                              \
+        -metadata artist='---[ tTh ]---'        \
+        -metadata title='awesome video'         \
         stereo.mp4
 \end{lstlisting}
 
+Il existe environ un gazillion d'options pour encoder avec ffmpeg.
+Bon courage pour toutes les explorer, voire même juste les comprendre.
+
 \subsection{Et encore ?}\index{krita}\index{geeqie}
 
 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},
+parce que recompiler tout Gimp juste pour ça, c'est un peu overkill.
 
-% -------------------------------------------------------------------
 % ===================================================================
 \section{Le flou temporel}
 
-Et si nous jouions sur l'axe du temps ?
+\textit{\hspace{7em}Et si nous jouions sur l'axe du temps ?}
 
-Nous avons plus ou moins la magie du cumul sur la prise de vue
-d'\textbf{image} en enchainant plusieurs capture d'image.
+Nous avons déja plus ou moins la magie du cumul sur la prise de vue
+d'\textbf{image} en enchainant plusieurs captures d'image accumulées
+en une seule.
 Maintenant, voyons ce que l'on peut faire à partir de plusieurs images.
 On peut d'abord penser faire une moyenne (ou la somme, en fait) de toutes
 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
+l'ordre aux image traitées soit en entrée soit en sortie.
+Je pense qu'un schéma\footnote{omg, apprendre un nouveau truc en
+\LaTeX, quel challenge étourdissant !} s'impose.
 
-\subsection{\textsl{moving average}}
 
-\texttt{./fonderie} : Basé sur la moyenne mobile, avec une structure de
+\subsection{\texttt{./fonderie} : \textsl{moving average}}
+
+Basé sur la moyenne mobile, avec une structure de
 fifo\index{fifo} particulièrement mal conçue.
+Qui, en fait, n'est pas vraiment un fifo, mais plutôt un buffer
+circulaire. Pour chaque image source, elle est lue, passe dans la chaine de
+filtre d'entrée et est insérée dans ce buffer.
+Ensuite on calcule la moyenne des images contenues dans ce buffer. 
+Et pour conclure, cette image moyennée passe au travers de la
+chaine de filtre de sortie, avant d'être enregistrée en PNG\index{PNG}
+dans le répertoire de destination.
+
+\begin{verbatim}
+*** fonderie compiled Jan 23 2023, 10:43:56, pid 23366
+options:
+        -E      input:filter:chain
+        -F      output:filter:chain
+        -I      input glob pattern
+        -L      list available filters
+        -O      output directory
+        -T      fifo size
+        -v      increase verbosity
+\end{verbatim}
+
+Euh, c'est quoi un '\textsl{input glob pattern}' ?
+
+C'est ce qui vous permet
+de sélectionner un peu les images que vous voulez traiter, exactement
+comme vous pourriez le faire avec un shell classique.
+Par exemple pour choisir une image sur dix, le glob-pattern sera
+'\texttt{frames/????0.fimg}', et vous trouverez les explications détaillées
+dans le manuel~: \texttt{glob(7)}, et \texttt{glob(3)} pour la
+fonction utilisée.
+
+% -------------------------------------------------------------------
 
 \subsection{Interpolator}\index{interpolator}
 
-Juste des calculs pas si simple que ça.
+Pour le moment, juste des calculs pas si simple que ça.
+Je pense qu'il faudra
+se lancer dans des calculs splinesques pour améliorer les choses dans
+la création des images intermédiaires.
+Voyons d'abord le principe actuel.
+
+Nous avons une série de centaines, voire de milliers, de photos.
+En parcourant cette liste, nous allons en prélever une sur $N$,
+et entre celle-ci et la
+précédente prélevée, nous allons calculer par interpolation
+\textbf{linéaire} $N - 1$ images intermédiaires, et les
+intercaler entre nos deux sélections pour générer le
+flux de sortie,
+ce qui devrait nous donner un ralenti de bon aloi.
+
+\begin{verbatim}
+usage:
+        interpolator [options] <inglob> <outdir> <nbsteep>
+options:
+        -E i:bla:k      input  filter chain
+        -F name:j       output filter chain
+        -n              make negative
+        -S nn           mysterious sort
+        -L              list available filters
+        -v              increase verbosity
+\end{verbatim}
+
+L'option « mysterious sort » mérite bien son nom. Cette friture a
+été écrite il y a bien longtemps pour un projet précis, et les
+résultats ont été décevants. Je pense qu'il est toxique de
+l'utiliser pour le moment\footnote{Ou le repenser différent ?}.
+
+% -------------------------------------------------------------------
+
 
 \subsection{Singlepass}
 
 Ce programme \texttt{singlepass} prétend vous permettre de tester
-tous les filtres disponibles, dont on peut avoir la liste
+tous les filtres disponibles, et dont on peut avoir la liste
 avec l'option \texttt{-L}\footnote{liste hélas peu machinable.}
 
-\subsection{Déviance}
+\begin{verbatim}
+usage:
+        -F      define:the:filter:chain
+        -g      input glob pattern
+        -L      list available filters
+        -O      /output/directory   (default ./p8)
+        -r N    repetiiing factor
+        -v      spit more messages
+\end{verbatim}
+
+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{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{:)}
+
+% -------------------------------------------------------------------
+
+\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 dedans.
+mais il y aura du zbuffer\index{zbuffer} dedans.
+
+% ===================================================================
+
+\section{Expérimentations} \index{experimental}
+
+Il m'arrive parfois d'avoir de vagues idées d'image, et donc de logiciel,
+qui tournent dans un coin de la tête.
+Parfois je songe à une fonction qui me
+serait bien utile, mais j'ai des doutes sur son 
+\textsc{api}\footnote{Application Programming Interface}\index{api}
+qui soit  à la fois simple et complète. Je fais donc des essais.
+Parfois j'imagine confusément un algorithme\index{algorithme} tordu
+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
@@ -1625,7 +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.
+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 ».
 
 % -------------------------------------------------------------------
 

essai.c

@@ -18,14 +18,17 @@ int		verbosity;
 void fait_un_dessin(FloatImg *dessin)
 {
 
+// fprintf(stderr, "je dessine dans %p\n", dessin);
+
 fimg_draw_something(dessin);
 
 }
 /* --------------------------------------------------------------------- */
-void help(int k)
+void help(void)
 {
 puts("Options :");
 puts("\t-d WxH\timage size");
+puts("\t-v\tincrease verbosity");
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@@ -34,14 +37,14 @@ int main(int argc, char *argv[])
 {
 FloatImg	fimgA, fimgB;
 int		foo, opt;
-int		W = 800, H = 600;
+int		W = 640, H = 480;
 double		tb;
 
 while ((opt = getopt(argc, argv, "d:hv")) != -1) {
 	switch(opt) {
 		case 'd':	parse_WxH(optarg, &W, &H);
 				break;
-		case 'h':	help(0);		break;
+		case 'h':	help();		break;
 		case 'v':	verbosity++;		break;
 		}
 	}
@@ -57,19 +60,19 @@ 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);
+		printf("%5d     / %5d\n", foo, NBP);
 		}
 	fait_un_dessin(&fimgB);
 	fimg_add_3(&fimgA, &fimgB, &fimgA);
 	// 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);

experiment/.gitignore

@@ -0,0 +1,14 @@
+
+
+*.fimg
+*.o
+*.pnm
+*.data
+
+assemblage
+extracteur
+fimg2obj
+mnt
+movepixels
+muxplanes
+tcache

experiment/Makefile

@@ -3,28 +3,31 @@
 #  some ugly experiments, do not use in production
 #
 
-COPT = -Wall -Wextra -fpic -g -DDEBUG_LEVEL=1 -lm
+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
+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 $@
 
 movepixels:	movepixels.c ${DEPS}
 	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
 
+mnt:		mnt.c ${DEPS}
+	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
+
+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 $< 

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.
 
@@ -9,4 +9,21 @@ Le contenu de ce répertoire doit donc être considéré comme
 **volatile**. Si vous y trouvez votre bonheur, il serait sage
 d'en faire une copie personnelle...
 
+## MNT
 
+Modèles numériques de terrain. Rien ne marche. Plein de maths.
+Un [code](mnt.c) complexe.
+
+## fimg2obj
+
+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).

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__,

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;
+}
 /* ------------------------------------------------------------ */

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

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   %s %s\n", argv[0], __DATE__, __TIME__);
-	fimg_print_version(1);
-	}
-
-infile = argv[optind];	outfile = argv[optind+2];
-fprintf(stderr, "%s   %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;
-}
-/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */

experiment/fimg2obj.c

@@ -0,0 +1,67 @@
+
+/*
+ *		another ugly experiment
+ */
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+#include  <stdint.h>
+
+#include  "../floatimg.h"
+
+int		verbosity;
+
+/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
+
+int convert_fimg_to_obj(char *fimgfname, char *objfname, int mode)
+{
+FloatImg	src;
+int		foo, x, y;
+FILE		*fp;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s'  '%s'  %d )\n", __func__,
+			fimgfname, objfname, mode);
+#endif
+
+if (mode) {
+	fprintf(stderr, "in %s(), mode must be 0, was %d\n", __func__, mode);
+	}
+
+foo = fimg_create_from_dump(fimgfname, &src);
+if (foo) {
+	fprintf(stderr, "err %d loading %f\n", foo, fimgfname);
+	return foo;
+	}
+
+
+	
+return -1;
+}
+/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
+
+int main(int argc, char *argv[])
+{
+int		foo, opt;
+char		*infile  = "foo.fimg";
+
+fprintf(stderr, "*** fimg2obj   (%s %s)\n", __DATE__, __TIME__);
+
+verbosity = 0;
+
+#if 0
+for (foo=0; foo<argc; foo++) {
+	fprintf(stderr, "%9d   %s\n", foo, argv[foo]);
+	}
+#endif
+
+foo = convert_fimg_to_obj(infile, "foo.obj", 0);
+if (foo) {
+	fprintf(stderr, "convertor give us %d\n", foo);
+	exit(1);
+	}
+
+return 0;
+}
+
+/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */

experiment/mnt.c

@@ -0,0 +1,239 @@
+/*
+ *	Modeles Numeriques de Terrain  --  UGLY CODE INSIDE !!
+ *
+ */
+
+#include   <stdio.h>
+#include   <math.h>
+#include   <stdlib.h>
+#include   <stdint.h>
+#include   <string.h>
+
+#include   "../floatimg.h"
+
+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;
+float		pixel, minp, maxp;
+int		*counts;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__,
+				img, fname, nbslots);
+#endif
+
+if (FIMG_TYPE_GRAY != img->type) {
+	fprintf(stderr, "%s: image is not in greylevel\n", __func__);
+	return -2;
+	}
+
+/* allocate memory for histogram computation */
+counts = calloc(nbslots, sizeof(int));
+if (NULL == counts) {
+	fprintf(stderr, "malloc fail in %s\n", __func__);
+	abort();
+	}
+
+nbpix = img->width * img->height;
+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);
+
+*pmax = maxp;		/* copy value for the caller */
+
+/* calcul de l'histogramme avec scaling */
+for (offset=0; offset<nbpix; offset++) {
+	pixel = img->R[offset];
+	ival = (int)((pixel * (float)nbslots) / maxp);
+	counts[ival]++;
+	// fprintf(stderr, "%6d    %10.6f    %i\n", offset, pixel, ival);
+	}
+
+if (NULL != fname)
+	{
+	printf_histo_gray(fname, counts, nbslots);
+	}
+
+/* garbage collect stuff */
+free(counts);
+
+return 0;
+}
+/* ------------------------------------------------------------------- */
+/*
+ *		Second try - ahem?
+ */
+int brotche_mnt_style(FloatImg *src, FloatImg *dst)
+{
+FloatImg	tmp;
+int		x, y, foo;
+int		offset;
+float		z1, z2, z3, z4;
+float		a, b, c;
+float		pente, minp, maxp, seuil;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
+#endif
+
+/*
+ *	trying some preprocessor filters
+ */
+foo = fimg_lissage_3x3(src);
+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);
+
+#define W    (src->width)
+#define DX   1.0
+#define DY   1.0
+
+/* allocate a graylevel image for storing la 'pente'		*/
+memset(&tmp, 0, sizeof(FloatImg));
+foo = fimg_create(&tmp, src->width, src->height, FIMG_TYPE_GRAY);
+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++) {
+		offset = (y * W) + x;
+		z1 = src->R[offset];
+		z2 = src->R[offset+1];
+		z3 = src->R[offset+W];
+		z4 = src->R[offset+W+1];
+		a = ( z1 + z2 + z3 + z4) / 4.0;
+		b = (-z1 + z2 - z3 + z4) / 2.0 / DX;
+		c = (-z1 - z2 + z3 + z4) / 2.0 / DY;
+		pente = atanf(sqrt(b*b + c*c));
+		tmp.R[offset] = pente;
+		}
+	}
+
+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) {
+		if (pente < minp)	minp = pente;
+		}
+	if (pente > maxp)		maxp = pente;
+	}
+// 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) {
+		dst->R[offset] = -pente;
+		dst->G[offset] = -pente;
+		}
+	else	{
+		dst->B[offset] = pente;
+		dst->G[offset] = pente;
+		}
+	}
+
+foo = fimg_killborders(dst);
+if (foo) fprintf(stderr, "    killborder -> %d\n", foo);
+
+/* clean the memory */
+fimg_destroy(&tmp);
+
+return 0;
+}
+/* ------------------------------------------------------------------- */
+int main(int argc, char *argv[])
+{
+FloatImg	src, dst;
+char		*infile, *outfile;
+int		foo;
+
+verbosity = 1;		/* FIXME */
+
+if (3 != argc) {
+	fprintf(stderr, "'%s' need 2 args : infile & outfile\n", argv[0]);
+	fimg_print_version(0);
+	exit(1);
+	}
+
+infile = argv[1];	outfile = argv[2];
+
+if (verbosity) fprintf(stderr,"*** MNT    %s -> %s\n", infile, outfile);
+
+foo = fimg_create_from_dump(infile, &src);
+if (foo) {
+	fprintf(stderr, "err %d loading image '%s'\n", foo, infile);
+	exit(1);
+	}
+
+foo = fimg_clone(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "err %d cloning image\n", foo);
+	exit(1);
+	}
+fimg_clear(&dst);
+
+foo = brotche_mnt_style(&src, &dst);
+if (foo) {
+	fprintf(stderr, "something weird happen %d\n", foo);
+	exit(1);
+	}
+
+foo = fimg_export_picture(&dst, outfile, 0);
+if (foo) {
+	fprintf(stderr, "err %d exporting to %s\n", foo, outfile);
+	exit(1);
+	}
+
+/* clean the memory */
+fimg_destroy(&src);
+fimg_destroy(&dst);
+
+return 0;
+}
+/* ------------------------------------------------------------------- */

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

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;

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

floatimg.h

@@ -1,13 +1,59 @@
 /*
  *			floatimg.h
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+
  *			ugly code from tTh
- *	http://la.buvette.org/photos/cumul
+ *	http://la.buvette.org/photos/cumul/
+ *	https://git.tetalab.org/tTh/FloatImg
  */
 
-#define		FIMG_VERSION	175
+#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>
+
 
 /*
- *	in memory descriptor
+ *		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 {
@@ -18,6 +64,7 @@ typedef struct {
 	float		fval;
 	int		count;
 	float		*R, *G, *B, *A;
+	FimgMetaData	mdatas;			// added 20230912
 	int		reserved;
 	} FloatImg;
 
@@ -25,22 +72,12 @@ typedef struct {
  *	fimg file header (short version)
  */
 typedef struct {
-	char		magic[8];
+	char		magic[8];	/* this is not an asciiz ! */
 	int32_t		w, h, t;
+	/*
+	 *  what about the packing ?
+	 */
 	} FimgFileHead;
-/*
- *		new 11 mars 2022
- */
-typedef struct {
-	char		magic[8];
-	struct timeval	timestamp;
-	int32_t		count;
-	float		fval;
-	char		idcam[32];
-	int32_t		origin;			// enum ?
-	} FimgMetaData;
-/*
- *	we MUST look at packing and endianess problems NOW */
 
 
 #define MAGIC_AREA51	0xA5EA0051
@@ -111,22 +148,27 @@ int fimg_mul_3(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
 
-/*	funcs/filtrage.c		*/
 
+/* ---------------------------------------------------- */
+/*	funcs/filtrage.c		*/
 typedef struct {
 	float		matrix[9];
 	float		mult;
 	float		offset;
 	} FimgFilter3x3;
-
+/*
+ *	this module contains bugs...
+ */
 int fimg_killborders(FloatImg *img);
 int fimg_lissage_2x2(FloatImg *img);
+int fimg_lissage_3x3(FloatImg *img);
 int fimg_show_filter(char *title, FimgFilter3x3 *filtr);
 int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
 
-
 int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int reverse);
 
+/* ---------------------------------------------------- */
+
 /*	 module sfx0.c			*/
 int fimg_killcolors_a(FloatImg *fimg, float fval);
 int fimg_killcolors_b(FloatImg *fimg, float fval);
@@ -141,14 +183,15 @@ int fimg_binarize(FloatImg *pimg, int notused);
 int fimg_trinarize(FloatImg *pimg, int notused);
 
 /*	 module sfx3.c			*/
+int fimg_make_rndfluffy_lines(FloatImg *src, FloatImg *dst, int rndt);
 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);
@@ -182,6 +225,14 @@ int fimg_mix_rgb_gray(FloatImg *img, float mix);
 int     fimg_shift_to_zero(FloatImg *s, FloatImg *d, float coefs[6]);
 int     fimg_auto_shift_to_zero(FloatImg *s, FloatImg *d);
 
+/*	funcs/falsecolors.c		*/
+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);
 
@@ -195,8 +246,9 @@ int fimg_classif_trial(FloatImg *src, FloatImg*dst, float fval, int notused);
 int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused);
 int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused);
 
-/*	module funcs/??????.c		*/
+/*	module funcs/equalize.c		*/
 int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax);
+int fimg_equalize(FloatImg *src, double vmax);
 
 int fimg_mk_gray_from(FloatImg *src, FloatImg*dst, int k);
 int fimg_desaturate(FloatImg *src, FloatImg *dst, int notused);
@@ -208,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);
 
@@ -217,16 +268,24 @@ 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, float fmax, int mode);
 
 /*	FIMG native file module		*/
 int   fimg_fileinfos(char *fname, int *datas);
 int   fimg_dump_to_file(FloatImg *head, char *fname, int notused);
+int fimg_dumpmd_to_file(FloatImg *fi, char *nm, FimgMetaData *pmd, int nu);
+
 int   fimg_load_from_dump(char *fname, FloatImg *where);
 int   fimg_create_from_dump(char *fname, FloatImg *head);
+
 /*	FIMG metadata module		*/
 int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused);
-int fimg_default_metadata(FimgMetaData *pmd);
+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);
@@ -235,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);
@@ -244,12 +302,15 @@ int   fimg_meanvalues(FloatImg *head, float means[4]);
 int   fimg_to_gray(FloatImg *head);
 int   fimg_add_cste(FloatImg *fi, float value);
 int   fimg_mul_cste(FloatImg *fi, float value);
+int   fimg_div_cste(FloatImg *fi, float value);
 int   fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused);
 int   fimg_absolute(FloatImg *fimg);
 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);

funcs/.gitignore

@@ -0,0 +1,10 @@
+
+tpnm
+t
+*.o
+*.png
+*.gif
+*.fits
+*.tiff
+
+

funcs/Makefile

@@ -9,6 +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 thermocolor.o fmorpho.o				\
 	geometry.o rotate.o fimg-openexr.o			\
 	equalize.o fimg-fits.o saturation.o histogram.o		\
 	fimg-dicom.o						\
@@ -18,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						\
@@ -27,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
@@ -59,6 +66,9 @@ incrustator.o:		incrustator.c  $(DEPS)
 displacement.o:		displacement.c  $(DEPS)
 	gcc $(COPT) -c $<
 
+fmorpho.o:		fmorpho.c  $(DEPS)
+	gcc $(COPT) -c $<
+
 fimg-png.o:		fimg-png.c $(DEPS)
 	gcc $(COPT) -c $<
 
@@ -137,6 +147,11 @@ qsortrgb.o:		qsortrgb.c $(DEPS)
 exporter.o:		exporter.c $(DEPS)
 	gcc $(COPT) -c $<
 
+falsecolors.o:		falsecolors.c $(DEPS)
+	gcc $(COPT) -c $<
+
+thermocolor.o:		thermocolor.c $(DEPS)
+	gcc $(COPT) -c $<
 
 hsv.o:		hsv.c $(DEPS)
 	gcc $(COPT) -c $<

funcs/README.md

@@ -2,28 +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 !
-
-## DICOM
-
-https://en.wikipedia.org/wiki/DICOM et ça semble bien compliqué :(
 
 ## Contours
 
-Détecter des contours est une activité respectable.
+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
@@ -32,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.

funcs/classif.c

@@ -15,7 +15,7 @@ extern int		verbosity;
 /* --------------------------------------------------------------------- */
 /* nouveau 2 octobre 2020, juste avant sonoptic de la pluie craignos	 */
 
-int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int notused)
+int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int flags)
 {
 float		minmax[6], delta[3], baryc[3];
 float		range, dist, rgb[3], dr, dg, db;
@@ -26,6 +26,8 @@ fprintf(stderr, ">>> %s ( %p %p %f %d )\n", __func__,
 					psrc, pdst, fval, notused);
 #endif
 
+if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
+
 if (FIMG_TYPE_RGB != psrc->type) {
 	fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
 	return -7;

funcs/decomprgb.c

@@ -23,15 +23,14 @@ extern int		verbosity;
 /*	A lot of strange and usefull parenthesis	*/
 
 /* == ---------------------------------------------------- == */
-
+#if DEBUG_LEVEL
 static float compute_z_value(float r, float g, float b)
 {
 double		dval;
 
-
-
 return 42.0;
 }
+#endif
 /* == ---------------------------------------------------- == */
 
 int fimg_decomp_rgbz_color(FloatImg *psrc, FloatImg *pdst, int k)
@@ -45,8 +44,12 @@ fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
 			psrc,  pdst, k);
 #endif
 
-fimg_clear(pdst);
+/*
+ *	XXX useless message ?
+ */
+if (k) { fprintf(stderr, "k=%d in %s\n", k, __func__); }
 
+fimg_clear(pdst);
 w2 = psrc->width/2;	h2 = psrc->height/2;
 
 for (y=0; y<h2; y++)
@@ -102,8 +105,12 @@ fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
 			psrc,  pdst, k);
 #endif
 
-fimg_clear(pdst);
+/*
+ *	XXX useless message ?
+ */
+if (k) { fprintf(stderr, "k=%d in %s\n", k, __func__); }
 
+fimg_clear(pdst);
 w2 = psrc->width/2;	h2 = psrc->height/2;
 
 for (y=0; y<h2; y++)

funcs/displacement.c

@@ -22,7 +22,6 @@ float		minmax[6];
 float		rgb[3];
 float		dltr, dltg, dltb;	/* delta des minmax */
 float		dispx, dispy;
-
 int		dstx, dsty;
 int		in, out;
 
@@ -47,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];
 
@@ -83,9 +82,7 @@ for (y=0; y<psrc->height; y++) {
 			fimg_put_rgb(pdst, dstx, dsty, rgb);
 			in++;
 			}
-
 		}
-
 	}
 
 if (verbosity) fprintf(stderr, "%s -> in %d out %d\n", __func__, in, out);

funcs/dithering.c

@@ -17,6 +17,17 @@ int fimg_dither_0(FloatImg *psrc, FloatImg *pdst, int flags)
 {
 int		x, y;
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, psrc, pdst, flags);
+#endif
+
+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++)

funcs/equalize.c

@@ -14,6 +14,47 @@
 extern int		verbosity;
 
 /* --------------------------------------------------------------------- */
+/*				new func: Wed 14 Sep 2022 11:28:04 AM CEST
+*/
+int fimg_equalize(FloatImg *src, double vmax)
+{
+float			mm[6];
+double			maxi, coef;
+int			foo;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p  %f )\n", __func__, src, vmax);
+#endif
+
+memset(mm, 0, 6*sizeof(float));
+foo = fimg_get_minmax_rgb(src, mm);
+if (foo) {
+	fprintf(stderr, "%s: err %d get_minmax\n", __func__, foo);
+	return foo;
+	}
+maxi = mm[1] > mm[3] ? (double)mm[1] : (double)mm[3];
+maxi = maxi  > mm[5] ?         maxi  : (double)mm[5];
+coef = vmax / maxi;
+
+if (verbosity) {
+	fprintf(stderr, "maximums  %.3f %.3f %.3f    %.3f\n",
+				mm[1], mm[3], mm[5], maxi);
+	fprintf(stderr, "vmax %f maxi %f multcoef = %g\n", vmax, maxi, coef);
+	}
+
+foo = fimg_mul_cste(src, (float)coef);
+if (foo) {
+	fprintf(stderr, "%s: err %d mul_cste\n", __func__, foo);
+	return foo;
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+/*
+ *
+ *	- wtf is this "void *vptr" thing ?
+ */
 int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax)
 {
 float			minmax[6];
@@ -32,6 +73,8 @@ if (foo) {
 	return foo;
 	}
 
+fprintf(stderr, "vptr is %p   vmax is %f\n", vptr, vmax);
+
 dr = minmax[1] - minmax[0];
 dg = minmax[3] - minmax[2];
 db = minmax[5] - minmax[4];
@@ -45,7 +88,7 @@ if ( (minmax[0]<0.0) || (minmax[2]<0.0) || (minmax[4]<0.0) ) {
 	return -4;
 	}
 
-// printf("deltas  %12.4g  %12.4g  %12.4g\n", dr, dg, db);
+fprintf(stderr, "deltas  %12.4g  %12.4g  %12.4g\n", dr, dg, db);
 
 return 0;
 }

funcs/exporter.c

@@ -25,6 +25,8 @@ fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__,
 				pic, fname, flags);
 #endif
 
+if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
+
 filetype = format_from_extension(fname);
 if (verbosity > 1) {
 	fprintf(stderr, "file %s have type %d\n", fname, filetype);

funcs/falsecolors.c

@@ -0,0 +1,83 @@
+/*
+ *	FloatImg library from tTh - really ugly code inside
+ *
+ *		F A L S E   C O L O R S
+ *						or fake colors ?
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+#include  <math.h>
+#include  "../floatimg.h"
+
+/* -------------------------------------------------------------- */
+/*	this is a global vars exported from main */
+extern	int	verbosity;
+
+/* -------------------------------------------------------------- */
+/*			TRUCS A VOIR
+
+f(x,y) = (((y & x) * (y - x)) % ((21 & x) * (y | 8))) ^ (~((x & 7) | (x % x)))
+
+
+*/
+/* -------------------------------------------------------------- */
+/* nouveau 18 mai 2022 */
+/* please explain the meaning of 'valf' parameter */
+int fimg_falsecolors_0(FloatImg *src, FloatImg *dst, int k, float valf)
+{
+int		x, y, offset;
+float		r, g, b, gray, maxv;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p  %d  %f )\n", __func__,
+					src, dst, k, valf);
+#endif
+
+if (k) {
+	fprintf(stderr, "%s : %d %f\n", __func__, k, valf);
+	}
+
+/* check validity of parameters */
+if (FIMG_TYPE_RGB != dst->type) {
+	fprintf(stderr, "in %s, picz at %p is not valid\n",
+			__func__, dst);
+	abort();
+		/* BLAM! */
+	}
+
+
+maxv = fimg_get_plane_maxvalue(src, 'r');
+fprintf(stderr, "%s: maxv of red plane = %f\n", __func__, maxv);
+
+/* enter big loop */
+offset = 0;
+for (y=0; y<src->height; y++) {
+	for (x=0; x<src->width; x++) {
+
+		gray = src->R[offset];
+
+		if (gray < maxv/2.0) {
+			r = gray * 2.0;
+			g = 0.0;
+			}
+		else 	{
+			r = 0.0;
+			g = gray * 2.0;
+			}
+		b = fmodf(gray*8.0, maxv);
+
+		dst->R[offset] = r;
+		dst->G[offset] = g;
+		dst->B[offset] = b;
+
+		/* and GOTO next pixel */
+		offset++;
+		}
+	}
+
+return 0;
+}
+/* -------------------------------------------------------------- */

funcs/filtrage.c

@@ -16,7 +16,7 @@ extern int		verbosity;
 int fimg_show_filter(char *title, FimgFilter3x3 *filtr)
 {
 float		*M;			/* alias of filter matrix */
-int		foo, idx;
+int		idx;
 float		sum, value;
 
 if (title)	fprintf(stderr, "--------- %s ---------\n", title);
@@ -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", sum);
+fprintf(stderr, "      value:  %8.3f\n", value);
 
 return 0;
 }
@@ -47,7 +47,7 @@ float		*M;			/* alias of filter matrix */
 double		dval;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, src, dst, filtr);
+fprintf(stderr, ">>> %s ( %p %p   %p )\n", __func__, src, dst, filtr);
 #endif
 
 if (src->type != FIMG_TYPE_RGB) {
@@ -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;
-
 	}
 }
 
@@ -200,7 +195,6 @@ for (idx=0; idx<h; idx++) {
 	}
 
 o = w * (h - 1);
-
 for (idx=0; idx<w; idx++) {
 #if FAST
 	img->R[idx] = 0.0;
@@ -222,6 +216,10 @@ int fimg_lissage_2x2(FloatImg *img)
 {
 int		foo;
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+#endif
+
 foo = fimg_lissage_2x2_a(img);
 if (foo) {
 	fprintf(stderr, "%s: fail %d\n", __func__, foo);
@@ -233,4 +231,54 @@ fimg_killborders(img);
 return foo;
 }
 /* -------------------------------------------------------------------- */
+/* -------------------------------------------------------------------- */
+/*
+ *	XXX inplace filtering is a BAD IDEA
+ */
+int fimg_lissage_3x3(FloatImg *img)
+{
+int		foo;
+FloatImg	tmp;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+#endif
+
+static FimgFilter3x3   lowpass = {
+                {
+                1.0,    2.0,    1.0,
+                2.0,    4.0,    2.0,
+                1.0,    2.0,    1.0,
+                },
+        16.0,   0.0
+        };
+
+foo = fimg_clone(img, &tmp, 1);
+if (foo) {
+	fprintf(stderr, "%s: clone -> %d\n", __func__, foo);
+	abort();
+	}
+foo = fimg_filter_3x3(&tmp, img, &lowpass);
+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);
+	abort();
+	}
+
+fimg_killborders(img);
+
+return 0;
+}
+/* -------------------------------------------------------------------- */
 

funcs/fimg-dicom.c

@@ -17,12 +17,12 @@ extern int verbosity;		/* must be declared around main() */
 int fimg_save_plane_as_dicom(FloatImg *src, char *outname,
 						char plane, int flags)
 {
-int		foo;
 float		*planeptr;
 
 fprintf(stderr, ">>> %s ( %p %s %c %d )\n", __func__, src, outname, plane, flags);
 
-planeptr = charplane2int(plane, src);
+planeptr = charplane2int(plane, src);		/* please explain XXX */
+fprintf(stderr, "planeptr is %p\n", planeptr);
 
 if (verbosity) {
 	fimg_describe(src, outname);

funcs/fimg-fits.c

@@ -32,6 +32,8 @@ long		naxes[2];
 fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__, src, outname, flags);
 #endif
 
+if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
+
 status = 0;
 
 switch (plane) {
@@ -52,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);

funcs/fimg-libpnm.c

@@ -14,17 +14,16 @@
 extern int		verbosity;
 
 /* --------------------------------------------------------------------- */
-static void print_struct_pam(struct pam *ppam, char *txt)
+static void print_struct_pam(struct pam *ppam, char *text)
 {
+printf("\ttext                %s\n", text);
+printf("\tsize                %d\n", ppam->size);
 
-printf("    size                %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);
 }
 /* --------------------------------------------------------------------- */
 
@@ -37,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);

funcs/fimg-png.c

@@ -171,7 +171,7 @@ unsigned char		*bytes, *bptr;
 double			maximum, fk;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %-25s ( %p '%s' 0x%x )\n", __func__, src, outname, flags);
+fprintf(stderr, ">>> %s ( %p '%s' 0x%x )\n", __func__, src, outname, flags);
 #endif
 
 if (flags) {

funcs/fimg-tiff.c

@@ -23,6 +23,9 @@ int			x, y, idx, foo;
 char			ligne[100];
 double			maximum, fk;
 
+if (flags) fprintf(stderr, "in %s, flags are 0x%04x, must be 0\n",
+				__func__,	flags);
+
 		/* bon, tout cela semble bien tortueux ! */
 
 if (FIMG_TYPE_RGB != src->type) {
@@ -45,6 +48,7 @@ if (verbosity) {
 tiff = TIFFOpen(fname, "w");
 if (NULL==tiff) {
 	fprintf(stderr, "erreur TIFFOpen\n");
+	free(linebuff);
 	return -6;
 	}
 

funcs/fmorpho.c

@@ -0,0 +1,89 @@
+/*
+  *			FLOATIMG
+ *			--------
+
+ *			F M O R P H O
+ *
+ * nouveau 30 septembre 2022  / integration 28 octobre 2022
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+
+/* --------------------------------------------------------------------- !*/
+static struct
+	{
+	int	x, y;
+	} deltas[] =
+{	{ -1,	-1, },
+	{  0,	-1, },
+	{  1,	-1, },
+	{ -1,	 0, },
+	{  0,	 0, },
+	{  1,	 0, },
+	{ -1,	 1, },
+	{  0,	 1, },
+	{  1,	 1 }
+};
+
+typedef struct
+	{
+	int		x, y;			// not used
+	float		r, g, b;
+	float		fgris;
+	int		rang;
+	} fpixel;
+
+static fpixel	pixels[9];
+
+/* --------------------------------------------------------------------- !*/
+static int comparaison_fgris(const void *A, const void *B)
+{
+return ((fpixel *)A)->fgris > ((fpixel *)B)->fgris;
+}
+/* --------------------------------------------------------------------- !*/
+/*
+ *		this is a klugy approch, sorry.
+ */
+int fimg_filtre_morpho_0(FloatImg *sfimg, FloatImg *dfimg, int index)
+{
+int		xs, ys, loop9;
+int		xp, yp;
+float		rgb[3];
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p   %d )\n", __func__, sfimg, dfimg, index);
+#endif
+
+if ( (index<0) || (index>8)) {
+	fprintf(stderr, " %s: bad index %d\n", __func__, index);
+#if MUST_ABORT
+	fflush(stderr);		abort();
+#endif
+	return -1;
+	}
+
+fimg_clear(dfimg);
+
+for (ys=1; ys<sfimg->height-1; ys++) {
+	for (xs=1; xs<sfimg->width-1; xs++) {
+		for (loop9=0; loop9<9; loop9++) {
+			xp = xs + deltas[loop9].x;
+			yp = ys + deltas[loop9].y;
+			fimg_get_rgb(sfimg, xp, yp, rgb);
+			pixels[loop9].fgris = rgb[0] + rgb[1] + rgb[2];
+			pixels[loop9].rang  = loop9;
+			}
+		qsort(&pixels, 9, sizeof(fpixel), comparaison_fgris);
+		rgb[0] = rgb[1] = rgb[2] = pixels[index].fgris;
+		fimg_put_rgb(dfimg, xs, ys, rgb);
+		}
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- !*/

funcs/geometry.c

@@ -27,6 +27,8 @@ fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
 			src, dst, notused);
 #endif
 
+if (notused)	fprintf(stderr, "notused %d in %s\n", notused, __func__);
+
 			/* no magic check here ? */
 if (dst->width || dst->height) {
 	fprintf(stderr, "*** %s: image at %p not empty\n", __func__, dst);
@@ -65,6 +67,8 @@ int		wd, hd;
 int		foo, x, y, x2, y2;
 float		ac;
 
+if (notused)	fprintf(stderr, "notused %d in %s\n", notused, __func__);
+
 if (dst->width || dst->height) {
 	fprintf(stderr, "*** %s: image at %p not empty\n", __func__, dst);
 	fimg_describe(dst, "destination halfsize 1");
@@ -106,19 +110,28 @@ 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		foo;
 int		xs, ys, xd, yd;
 int		count;
 float		rgb[3];
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, in, out, rect);
+#endif
+
 if (verbosity > 1) {
 	fimg_describe(in,  "extractor: source");
 	fimg_describe(out, "extractor: destination");
-	// print_rectangle(rect);
 	}
 
+/*
+ *	some sanity controls, please ! XXX
+ */
+
 count = 0;
 for (yd=0; yd<rect->h; yd++) {
 	ys = yd + rect->y;
@@ -132,7 +145,7 @@ for (yd=0; yd<rect->h; yd++) {
 		}
 	}
 
-// fprintf(stderr, "%s: %d pix moved\n", __func__, count);
+if (verbosity > 1) fprintf(stderr, "%s: %d pix moved\n", __func__, count);
 
 return 0;
 }
@@ -149,6 +162,8 @@ fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__,
 				src, dst, notused);
 #endif
 
+if (notused)	fprintf(stderr, "notused %d in %s\n", notused, __func__);
+
 if (fimg_images_not_compatible(src, dst)) {
 	fprintf(stderr, "bad karma in %s\n", __func__);
 	return -9;

funcs/hsv.c

@@ -85,7 +85,7 @@ float		hh, ff, p, q, t;
 long		i;
 
 if(hsv[1] <= 0.0) {       // < is bogus, just shuts up warnings
-        rgb[0] = rgb[1] = rgb[2] = hsv[2];
+        rgb[0] = rgb[1] = rgb[2] = (hsv[2] * scale);
         return 0;
 	}
 
@@ -131,7 +131,10 @@ int fimg_essai_hsv(char *fname)
 float		colors[3], values[3], newcols[3];
 int		foo, r, g, b;
 
+fprintf(stderr, "%s NOT writing to %s\n", __func__, fname);
+
 #define INC  16
+
 for (r=0; r<255; r+=INC) {
  for (g=0; g<255; g+=INC) {
   for (b=0; b<255; b+=INC) {

funcs/incrustator.c

@@ -20,23 +20,26 @@ static int check_boundaries(FloatImg *from, FloatImg *to, FimgArea51 *a51)
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, from, to, a51);
-fimg_printdims("from", from);
-fimg_printdims("to  ", to);
 #endif
 
+if (verbosity > 1) {
+	fimg_printdims("from", from);
+	fimg_printdims("to  ", to);
+	}
+
 /* just a small molly-guard */
 if ( (a51->w < 0) || (a51->h < 0) ) {
 	fprintf(stderr, "%s: fubar on %p\n", __func__, a51);
 	abort();		/* FY Bro ! */
 	}
 
-return -1;
+return 0;
 }
 /* ---------------------------------------------------------------- */
+/* XXX
 static int move_pixels(FloatImg *from, FloatImg *to,
 				FimgArea51 *a51, int flags)
 {
-
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %p %p 0x%04x )\n", __func__,
 				from, to, a51, flags);
@@ -44,7 +47,11 @@ fprintf(stderr, ">>> %s ( %p %p %p 0x%04x )\n", __func__,
 
 return -1;
 }
+*/
 /* ---------------------------------------------------------------- */
+/*
+ *	See also:    fimg_extractor() in geometry.c
+ */
 int fimg_incrustator_0(FloatImg *psrc, FloatImg *pdst,
 				int xpos, int ypos, int flags)
 {
@@ -58,6 +65,8 @@ fprintf(stderr, ">>> %s ( %p %p %d %d 0x%04X\n", __func__, psrc, pdst,
 							xpos, ypos, flags);
 #endif
 
+if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
+
 if (verbosity > 1) {
 	fimg_describe(psrc, "source");
 	fimg_describe(pdst, "destination");
@@ -67,10 +76,15 @@ if (verbosity > 1) {
 area.x = xpos;		area.y = ypos;
 area.w = psrc->width;	area.h = psrc->height;
 foo = check_boundaries(psrc, pdst, &area);
+if (foo) {
+	fprintf(stderr, "Boudary error %d in %s:%d\n", foo, __func__, __LINE__);
+	return foo;
+	}
 
 if (	(xpos < 0)  || (xpos > pdst->width  - psrc->width)  ||
 	(ypos < 0)  || (ypos > pdst->height - psrc->height) ) {
-	fprintf(stderr, "%s: boudary error\n", __func__);
+	fprintf(stderr, "%s: boudary error, x=%d y=%d\n", __func__,
+					    xpos, ypos);
 	return -2;
 	}
 

funcs/killrgb.c

@@ -20,12 +20,12 @@ int		line, col;
 int		ir;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p  %p  %d )\n", __func__,
-			  src, dst, k);
+fprintf(stderr, ">>> %s ( %p  %p  %d )\n", __func__, src, dst, k);
 #endif
 
-fimg_clear(dst);
+if (k) { fprintf(stderr, "in %s k was %d\n", __func__, k); }
 
+fimg_clear(dst);
 ir = 0;
 
 for (line=0; line<src->height; line++) {

funcs/misc-plots.c

@@ -10,6 +10,11 @@
 #include  "../floatimg.h"
 
 /* --------------------------------------------------------------------- */
+/*
+ *********************************************
+ *       SEGFAULT SI IMAGE TROP PETITE       *
+ *********************************************
+*/
 
 int fimg_test_pattern(FloatImg *fimg, int type, double dval)
 {
@@ -26,6 +31,12 @@ if (fimg->type != FIMG_TYPE_RGB) {
 	return -6;
 	}
 
+fprintf(stderr, "ENTERING %s\n", __func__);
+
+if (type) {
+	fprintf(stderr, "%s : %d %f\n", __func__, type, dval);
+	}
+
 /* rampe de primaires dans le quart du haut */
 val = (float)dval;
 for (x=0; x<fimg->width; x++) {
@@ -46,7 +57,7 @@ for (x=0; x<fimg->width; x++) {
 			fimg_plot_rgb(fimg, x, y, fr, fg, fb);
 	}
 
-k = fimg->height / 4;
+k = (fimg->height / 4) + 20;
 for (x=0; x<fimg->width; x++) {
 	val =  ((double)x / (double)fimg->width) * dval;
 	for (y=0; y<20; y++) {
@@ -56,6 +67,27 @@ for (x=0; x<fimg->width; x++) {
 	// fprintf(stderr, " %6d   %f\n", x, val);
 	}
 
+
+k = (fimg->height / 4) + 90;
+for (x=0; x<fimg->width; x++) {
+	val =  ((x%8)<4) ? dval : 0.0;
+	for (y=0; y<20; y++) {
+		fimg_plot_rgb(fimg, x, k+y, val, val, val);
+		fimg_plot_rgb(fimg, x, k+y+20, dval-val, dval-val, dval-val);
+		}
+	}
+
+k = (fimg->height / 4) + 140;
+for (x=0; x<fimg->width; x++) {
+	for (y=0; y<20; y++) {
+		val =  drand48() * dval;
+		fimg_plot_rgb(fimg, x, k+y, val, val, val);
+		fimg_plot_rgb(fimg, x, k+y+20, dval-val, dval-val, dval-val);
+		}
+	}
+
+fprintf(stderr, "ALIVE    %s\n", __func__);
+
 return 0;
 }
 /* --------------------------------------------------------------------- */

funcs/pixelize.c

@@ -32,7 +32,7 @@ switch(largeur) {
 	case 8:	 case 16: case 32:
 		break;
 	default:
-		fprintf(stderr, "pixeliz bad width %d\n", largeur);
+		fprintf(stderr, "%s: bad width %d\n", __func__, largeur);
 		return -77;
 	}
 
@@ -58,8 +58,8 @@ return 0;
 /*   --------------------------------------------------------------   */
 /*
  *	un essai dans la roulotte :)
- *	11 oct 2021 : premier jet, essai concluant, mais nécessite
- *		du travail sur les rand() pour être plus 'noisy'
+ *	11 oct 2021 : premier jet, essai concluant, mais necessite
+ *		du travail sur les rand() pour etre plus 'noisy'
  *
  */
 int fimg_pixelize_h_rnd(FloatImg *psrc, FloatImg *pdst, int largeur)
@@ -68,6 +68,8 @@ static int	count = 0;
 static int	flag  = 0;
 int		foo;
 
+/* may be a mollyguard on 'largeur' parameter ? */
+
 if (0==count) {
 	if (flag) {
 		count = irand2(5, 10);
@@ -87,16 +89,13 @@ if (verbosity) {
 	fprintf(stderr, "%s: count=%d flag=%d\n", __func__, count, flag);
 	}
 
-foo = fimg_pixelize_h_0(psrc, pdst, flag ? 8 : 32);
+foo = fimg_pixelize_h_0(psrc, pdst, flag ? largeur : 32);
 if (foo) {
-	fprintf(stderr, "PANIC in %s\n", __func__);
-	abort();
+	fprintf(stderr, "pixelize_h_0 give err %d  in %s\n", foo, __func__);
 	}
 
 count--;		/* nice trick bro */
 
 return 0;
 }
-
-
 /*   --------------------------------------------------------------   */

funcs/plasmas.c

@@ -31,13 +31,11 @@ for (y=0; y<img->height; y++) {
 	for (x=0; x<img->width; x++) {
 		dx = ((double)x/(double)img->width) - 0.5000;
 
-		rgb[0] = sin(dx*10 + time) + 1.0;
-		rgb[1] = sin(dx*12 + time) + 1.0;
-		rgb[2] = sin(dx*14 + time) + 1.0;
+		rgb[0] = sin(dx*10 + time + dy) + 1.0;
+		rgb[1] = sin(dx*12 + time + dy) + 1.0;
+		rgb[2] = sin(dx*14 + time + dy) + 1.0;
 		fimg_put_rgb(img, x, y, rgb);
-
 		}
-
 	}
 
 return 0;

funcs/qsortrgb.c

@@ -28,6 +28,8 @@ int		foo, szimg;
 fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
 #endif
 
+if (notused) { fprintf(stderr, "%s notused != 0, WTF ?\n", __func__); }
+
 if (FIMG_TYPE_RGB != psrc->type) {
 	fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
 	return -7;
@@ -78,6 +80,8 @@ float		rgb[3];
 fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
 #endif
 
+if (notused) { fprintf(stderr, "%s notused != 0, WTF ?\n", __func__); }
+
 if (FIMG_TYPE_RGB != psrc->type) {
 	fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
 	return -7;

funcs/rampes.c

@@ -5,6 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdint.h>
+#include  <stdlib.h>
 #include  <sys/time.h>
 
 #include  "../floatimg.h"
@@ -23,8 +24,7 @@ if (FIMG_TYPE_RGB != img->type) {
 	fprintf(stderr, "%s bad type\n", __func__);
 	return -6;
 	}
-for (x=0; x<img->width; x++)
-	{
+for (x=0; x<img->width; x++) {
 	value = (float)x / (float)img->width;
 	value *= dcoef;
 	for (y=0; y<img->height; y++) {
@@ -51,11 +51,10 @@ if (FIMG_TYPE_RGB != img->type) {
 	fprintf(stderr, "%s bad type\n", __func__);
 	return -6;
 	}
-for (y=0; y<img->height; y++)
-	{
-	value = (float)y / (float)img->height;
+for (x=0; x<img->width; x++) {
+	value = (float)x / (float)img->width;
 	value *= dcoef;
-	for (x=0; x<img->width; x++) {
+	for (y=0; y<img->height; y++) {
 		fimg_plot_rgb(img, x, y, value, value, value);
 		}
 	}
@@ -63,3 +62,52 @@ for (y=0; y<img->height; y++)
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/*				nouveau 19 septembre 2022
+ *
+ *	6 octobre 2023 : rajout du parametre 'fmax'
+ */
+
+int fimg_do_stripes(FloatImg *img, float fmax, int mode)
+{
+int		x, y, quad;
+float		*ligne;
+float		fr, fg, fb;
+
+fprintf(stderr, ">>> %s ( %p %f %d )\n", __func__, img, fmax, mode);
+
+/*
+ *	allocate and fill a lookup table
+ */
+if (NULL==(ligne=malloc(img->width*sizeof(float)))) {
+	fprintf(stderr, "%s: malloc fail\n", __func__);
+	exit(1);
+	}
+for (x=0; x<img->width; x++) {
+	ligne[x] = (float)x / (float)img->width;
+	ligne[x] *= fmax;
+	}
+
+/*
+ *	build the pixels
+ */
+for (y=0; y<img->height; y++)
+	{
+	quad = (y*4) / img->height ;
+	for (x=0; x<img->width; x++) {
+		fr = fg = fb = ligne[x];
+		switch(quad) {
+			case 0:		fg = fb = 0;		break;
+			case 1:		fr = fb = 0;		break;
+			case 2:		fr = fg = 0;		break;
+			case 3:					break;
+			default:	abort();		break;
+			}
+		fimg_plot_rgb(img, x, y, fr, fg, fb);
+		}
+	}
+
+free(ligne);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */

funcs/recurse.c

@@ -7,6 +7,7 @@
 #include   <math.h>
 #include  <stdint.h>
 #include  <sys/time.h>
+#include  <stdlib.h>
 
 #include   "../floatimg.h"
 
@@ -22,8 +23,18 @@ int fimg_recursion_proto(FloatImg *src, FloatImg *dst, int notused)
 fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, notused);
 #endif
 
+if (notused) {
+	fprintf(stderr, "%s parameter notused is %d, must be 0\n", 
+			__func__, notused);
+	return -2;
+	}
+
 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

funcs/rotate.c

@@ -25,6 +25,8 @@ fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
 				src, dst, notused);
 #endif
 
+if (notused)	fprintf(stderr, "notused %d in %s\n", notused, __func__);
+
 if (src->type != FIMG_TYPE_RGB) {
 	fprintf(stderr, "%s: src type %d not valid\n", __func__,
 					src->type);

funcs/sfx0.c

@@ -26,7 +26,7 @@ if (FIMG_TYPE_RGB != fimg->type) {
 
 nbpix = fimg->width * fimg->height;
 for (foo=0; foo<nbpix; foo++) {
-	if (fimg->R[foo] > fimg->G[foo])
+	if ((fimg->R[foo]+fval) > fimg->G[foo])
 		fimg->B[foo] = fimg->R[foo];
 	else
 		fimg->B[foo] = fimg->G[foo];
@@ -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)
 {
@@ -50,7 +50,7 @@ if (FIMG_TYPE_RGB != fimg->type) {
 
 nbpix = fimg->width * fimg->height;
 for (foo=0; foo<nbpix; foo++) {
-	if (fimg->R[foo] > fimg->B[foo])
+	if ((fimg->R[foo]+fval) > fimg->B[foo])
 		fimg->G[foo] = fimg->R[foo];
 	else
 		fimg->G[foo] = fimg->B[foo];

funcs/sfx2.c

@@ -25,6 +25,11 @@ int		foo, size;
 fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
 #endif
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 foo = fimg_get_minmax_rgb(pimg, mm);
 mR = (mm[1] - mm[0]) / 2.0;
 mG = (mm[3] - mm[2]) / 2.0;
@@ -54,6 +59,11 @@ float		mm[6], mRa, mGa, mBa, mRb, mGb, mBb;
 float		*fptr;
 int		foo, size;
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
 #endif
@@ -93,4 +103,7 @@ for (foo=0; foo<size; foo++) {
 return 0;
 }
 /* -------------------------------------------------------------- */
-
+/*
+ *			ici, il manque le quaternize :)
+ */
+/* -------------------------------------------------------------- */

funcs/sfx3.c

@@ -9,6 +9,7 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdlib.h>
 #include  <stdint.h>
 #include  <sys/time.h>
 
@@ -16,6 +17,45 @@
 
 extern int		verbosity;
 
+/* -------------------------------------------------------------- */
+/* new    Sun 29 Jan 2023 10:01:39 PM CET
+
+*/
+int fimg_make_rndfluffy_lines(FloatImg *src, FloatImg *dst, int rndt)
+{
+int		x, y, ol;
+float		accu;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%p'  '%p'  %d )\n", __func__,
+				src, dst, rndt);
+#endif
+
+if (fimg_images_not_compatible(src, dst)) {
+	/* be hard for the lamers */
+	fprintf(stderr, "compatibility OUPS in %s\n", __func__);
+	abort();
+	}
+
+for (y=0; y<src->height; y++) {
+	ol = y * src->width;
+	if (rndt < (rand() % 100)) {
+		accu = 0.0;
+		for (x=0; x<src->width; x++)	accu += src->R[ol + x];
+		accu /= (float)src->width;
+		for (x=0; x<src->width; x++)	dst->R[ol + x] = accu;
+		}
+	else	{
+		for (x=0; x<src->width; x++) {
+			dst->R[ol+x] = src->R[ol+x];
+			dst->G[ol+x] = src->G[ol+x];
+			dst->B[ol+x] = src->B[ol+x];
+			}
+		}
+	}
+
+return 0;
+}
 /* -------------------------------------------------------------- */
 int fimg_crump_hard(FloatImg *src, FloatImg *dst, float kval, int notused)
 {
@@ -28,9 +68,15 @@ fprintf(stderr, ">>> %s ( %p %p %f 0x%04x )\n", __func__,
 				src, dst, kval, notused);
 #endif
 
+if (notused) {
+	fprintf(stderr, "%s: notused was %d, must be 0\n",
+			__func__, notused);
+	}
+
 halfval = fimg_get_maxvalue(src) / 2.0;
 if (verbosity > 1) {
-	fprintf(stderr, "%s: halfval=%f\n", __func__, halfval);
+	fprintf(stderr, "%s: kval=%f & halfval=%f\n", __func__,
+				kval,	halfval);
 	}
 
 for (y=0; y<src->height; y++) {

funcs/sfx4.c

@@ -25,6 +25,11 @@ float		in[3], out[3];
 fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
 #endif
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 for (y=0; y<src->height; y++) {
 	for (x=0; x<src->width; x++) {
 		foo =  fimg_get_rgb(src, x, y, in);
@@ -48,13 +53,18 @@ return 0;
 int fimg_split_level(FloatImg *src, FloatImg *dst, int notused)
 {
 float		means[4];
-float		in[3];
+// float		in[3];
 int		foo, idx, surface;
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
 #endif
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 foo = fimg_meanvalues(src, means);
 if (foo) {
 	return -66;
@@ -73,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;
+}
 /* -------------------------------------------------------------- */

funcs/t.c

@@ -25,7 +25,8 @@ enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
 			Displace, ReadPNG, Plasmas, Hilight, OpenEXR,
 			Geometrie, FileType, Mirror, KillRGB,
 			Pixelize,SplitLevel, DecompRgbz, DecompRgbg,
-			Rectangle, Dicom  };
+			Rectangle, Dicom, Fakolor0, Fakolor3,
+			Fmorpho0, Fluffy, ThermoCol, TriPtyq  };
 typedef struct {
 	char	*name;
 	int	Cmd;
@@ -60,6 +61,12 @@ Command commands[] = {
 	{ "decomprgbg",	DecompRgbg	},
 	{ "rectangle",  Rectangle	},
 	{ "dicom",      Dicom		},
+	{ "fakolor0",	Fakolor0	},
+	{ "fakolor3",	Fakolor3	},
+	{ "fmorpho0",	Fmorpho0	},
+	{ "fluffy",	Fluffy		},
+	{ "thermocol",	ThermoCol	},
+	{ "triptyq",    TriPtyq		},
 	{ NULL,		0		}
 	} ;
 
@@ -97,13 +104,17 @@ fprintf(stderr, "options:\n");
 fprintf(stderr, "\t-k 1.414\tset float value\n");
 fprintf(stderr, "\t-l\t\tlist tests\n");
 fprintf(stderr, "\t-o \t\toutfile\n");
+fprintf(stderr, "\t-v \t\tincrease verbosity\n");
 
-fprintf(stderr, "commands:\n");
-pcmd = commands;
-while (pcmd->name) {
-	fprintf(stderr, "\t%-15s   %d\n", pcmd->name, pcmd->Cmd);
-	pcmd++;
+if (verbosity) {
+	fprintf(stderr, "commands:\n");
+	pcmd = commands;
+	while (pcmd->name) {
+		fprintf(stderr, "\t%-15s   %d\n", pcmd->name, pcmd->Cmd);
+		pcmd++;
+		}
 	}
+
 fprintf(stderr, "\ncompiled on "__DATE__" at "__TIME__"\n");
 
 if (k)  fimg_print_version(k);
@@ -248,6 +259,23 @@ switch(opt) {
 	case Dicom:
 		foo = essai_dicom(filename, outfile, 0);
 		break;
+	case Fakolor0:
+		foo = essai_0_fausses_couleurs(outfile, 0);
+		break;
+	case Fmorpho0:
+		foo = essai_fmorpho_0(filename, "/tmp/fmorpho", 0);
+		break;
+	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);
@@ -256,7 +284,7 @@ switch(opt) {
 	}
 
 if (foo) {
-	fprintf(stderr, "******* Essai --> %d\n", foo);
+	fprintf(stderr, "******* essai --> %d\n\n", foo);
 	}
 
 fprintf(stderr, "++++++++++++ end of '%s' pid %d\n", command, getpid());

funcs/tests.c

@@ -1,4 +1,7 @@
 /*
+ *			FLOATIMG
+ *			--------
+
  *	tests des fonctions diverses - subroutines
 	see also: t.c
  */
@@ -17,7 +20,125 @@
 
 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
+ */
+int essai_fmorpho_0(char *infile, char *basefname, int k)
+{
+FloatImg	src, dst;
+int		idx, foo;
+char		fname[100];
+
+fprintf(stderr, ">>> %s ( '%s'  '%s'  %d )\n", __func__, infile, basefname, k);
+
+if (k) {
+	fprintf(stderr, "%s k=%d must be 0\n", __func__, k);
+	return -6;
+	}
+
+if (NULL == infile ) {
+	foo = fimg_create(&src, W, H, FIMG_TYPE_RGB);
+	if (foo) {
+		fprintf(stderr, "%s: create -> %d\n",__func__, foo);
+		return foo;
+		}
+	foo = fimg_test_pattern(&src, 0, 254.99);
+	if (foo) {
+		fprintf(stderr, "%s: test_pattern -> %d\n",__func__, foo);
+		return foo;
+		}
+	}
+else	{
+	foo = fimg_create_from_dump(infile, &src);
+	if (foo) {
+		fprintf(stderr, "%s: error %d loading '%s'\n", __func__, foo, infile);
+		return foo;
+		}
+	}
+
+fimg_save_as_pnm(&src, "foo.pnm", 0);
+
+foo = fimg_clone(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "%s: clone -> %d\n",__func__, foo);
+	return foo;
+	}
+
+for (idx=0; idx<9; idx++) {
+	sprintf(fname, "%s%04d.pnm", basefname, idx);
+	fprintf(stderr, "      ---> %s\n", fname);
+	foo = fimg_filtre_morpho_0(&src, &dst, idx);
+	if (foo) {
+		fprintf(stderr, "%s: got a %d at round %d\n", __func__, foo, idx);
+		return foo;
+		}
+	fimg_save_as_pnm(&dst, fname, 0);
+	}
+
+fimg_destroy(&src);	fimg_destroy(&dst);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+/* nouveau 18 mai 2022 */
+int essai_0_fausses_couleurs(char *dstfile, int type)
+{
+FloatImg	src, dst;
+int		foo;
+
+fprintf(stderr, "\nEssais fausses couleurs (type %d) -> '%s'\n", type, dstfile);
+
+foo = fimg_create(&src, W, H, FIMG_TYPE_RGB);
+foo = fimg_hdeg_a(&src, 12e3);
+// fimg_export_picture(&src, "debug.pnm", 0);
+foo = fimg_clone(&src, &dst, 0);
+foo = fimg_clear(&dst);
+
+foo = fimg_falsecolors_0(&src, &dst, type, 3.141592654);
+fprintf(stderr, "false colors 0 --> %d\n", foo);
+
+foo = fimg_export_picture(&dst, dstfile, 0);
+fimg_destroy(&src);	fimg_destroy(&dst);
+
+return -1;
+}
 /* --------------------------------------------------------------------- */
 int essai_dicom(char *inf, char *outf, int k)
 {
@@ -41,6 +162,10 @@ FloatImg	img;
 int		foo;
 int		rect[4];
 
+if (0 != k) {
+	fprintf(stderr, "in %s, k muste be 0, was %d\n", __func__, k);
+	}
+
 foo = fimg_create(&img, 320, 240, FIMG_TYPE_RGB);
 
 fimg_drand48(&img, 1.0);
@@ -225,6 +350,42 @@ if (foo) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/* new  Sun Feb 12 10:34:06 CET 2023 
+ */
+int essai_rndfluffy(char *infile, char *outfile, int k)
+{
+int		foo;
+FloatImg	src, dst;
+
+fprintf(stderr, ">>> %s ( '%s'  '%s'  %d )\n", __func__,
+			infile, outfile, k);
+
+foo = fimg_create_from_dump(infile, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		infile);
+	return foo;
+	}
+fprintf(stderr, "    %s loaded.\n", infile);
+
+fimg_clone(&src, &dst, 0);
+fprintf(stderr, "    %p cloned.\n", &src);
+
+foo = fimg_make_rndfluffy_lines(&src, &dst, 80);
+if (foo) {
+	fprintf(stderr, "err %d while making fluffy\n", foo);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outfile, 0);
+if (foo) {
+	fprintf(stderr, "%s: err %d exporting %s\n", __func__, foo, outfile);
+	return foo;
+	}
+fimg_destroy(&src);	fimg_destroy(&dst);
+
+return 0;
+}
 /* --------------------------------------------------------------------- */
 int essai_split_level(char *inf, char *outf, int flags)
 {
@@ -741,6 +902,10 @@ int essai_geometrie(char *infile, int notused)
 FloatImg	fimg, result;
 int		foo;
 
+if (0 != notused) {
+	fprintf(stderr, "in %s, k must be 0, was %d\n", __func__, notused);
+	}
+
 if (NULL != infile) {
 	fprintf(stderr, "loading %s\n", infile);
 	foo = fimg_create_from_dump(infile, &fimg);
@@ -879,13 +1044,17 @@ int essai_mire(char *outname, int notused)
 FloatImg	fimg;
 int		re, foo;
 
+if (0 != notused) {
+	fprintf(stderr, "in %s, k must be 0, was %d\n", __func__, notused);
+	}
+
 fimg_create(&fimg, 1280, 960, FIMG_TYPE_RGB);
 
 re = fimg_test_pattern(&fimg, 9, 1.0);
 if (re) {
 	fprintf(stderr, "fimg_test_pattern -> %d\n", re);
 	}
-foo = fimg_export_picture(&fimg, "mire.pnm", 0);
+foo = fimg_export_picture(&fimg, outname, 0);
 fprintf(stderr, "in %s, export give a %d value\n", __func__, foo);
 
 return 0;
@@ -1037,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;
+}
+/* --------------------------------------------------------------------- */

funcs/tests.h

@@ -8,6 +8,7 @@ int essai_miroir(char *inf, char *outf, int flags);
 int essai_killrgb(char *inf, char *outf);
 int essai_decomprgb_color(char *inf, char *outf);
 int essai_decomprgb_gray(char *inf, char *outf);
+int essai_rndfluffy(char *infile, char *outfile, int k);	/* sfx3.c */
 int essai_split_level(char *inf, char *outf, int flags);
 
 int essai_displacement(char *infile, char *outfile);
@@ -28,11 +29,15 @@ int essai_geometrie(char *infile, int notused);
 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);
 
 int essai_highlights(char *inf, char *outf, int ikoef, float fkoef);
 int essai_openexr(char *inf, char *outf, int flags);
+int essai_fmorpho_0(char *infile, char *basefname, int k);
 
 int essai_pixelize(char *infile, char *outfile);
 

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;
+}
+
+
+/* --------------------------------------------------------------------- */

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"
 

funcs/utils.c

@@ -108,7 +108,13 @@ return -1;
 /* --------------------------------------------------------------------- */
 int print_rectangle(char *str, FimgArea51 *rect)
 {
-printf("rect @ %p  '%s':\n\t %dx%d  at  %d,%d\n", rect, str,
+if (MAGIC_AREA51 != rect->magic) {
+	fprintf(stderr, "%s: bad magic number 0x%08X\n", __func__,
+						rect->magic);
+	return -666;
+	}
+
+printf("rect @ %p  '%s'  :\n\t %dx%d  at  %d,%d\n", rect, str,
 			rect->w, rect->h, rect->x, rect->y);
 return 0;
 }
@@ -120,17 +126,28 @@ int parse_rectangle(char *str, FimgArea51 *r, int notused)
 {
 int		x, y, w, h, foo;
 
-if (verbosity)
-	fprintf(stderr, "parsing %s\n", str);
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %s %p %d )\n", __func__, str, r, notused);
+#endif
+
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
+if (verbosity > 1) fprintf(stderr, "%s: parsing '%s'\n", __func__, 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;
+	r->magic = MAGIC_AREA51;
 	return 4;
 	}
+
+r->magic = 0xBAD;
+
 return -1;
 }
-
 /* --------------------------------------------------------------------- */
 int format_from_extension(char *fname)
 {

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,6 +10,8 @@ cp	tools/mkfimg tools/fimg2pnm tools/fimgops 	\
 	tools/png2fimg tools/fimgstats tools/fimgfx	\
 	tools/cumulfimgs tools/fimg2text		\
 	tools/fimghalfsize				\
+	tools/fimgmetadata tools/fimgfilters		\
+	tools/fimgextract				\
 	/usr/local/bin
 
 cp	v4l2/grabvidseq v4l2/video-infos		\

lib/Makefile

@@ -7,7 +7,7 @@ COPT = -Wall -Wextra -fpic -g   -no-pie -DDEBUG_LEVEL=0
 OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o	\
 	fimg-timers.o operators.o fimg-2gray.o		\
 	interpolate.o fimg-compare.o contrast.o		\
-	metadata.o
+	metadata.o alphachan.o
 
 DEPS = Makefile ../floatimg.h
 
@@ -24,6 +24,9 @@ t:	t.c ../libfloatimg.a $(DEPS)
 ../libfloatimg.a:	$(OBJS)
 	$(AR) r $@ $?
 
+alphachan.o:	alphachan.c $(DEPS)
+	gcc $(COPT) -c $<
+
 fimg-core.o:	fimg-core.c $(DEPS)
 	gcc $(COPT) -c $<
 

lib/README.md

@@ -0,0 +1,26 @@
+# Floatimg, the base/core library
+
+## 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.
+
+```
+#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.
+

lib/alphachan.c

@@ -0,0 +1,29 @@
+/*
+ *              alphachan.c
+ */
+
+#include  <stdio.h>
+#include  <stdint.h>
+#include	<sys/time.h>
+
+#include  "../floatimg.h"
+
+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;
+}
+/* ---------------------------------------------------------------- */

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",

lib/fimg-2gray.c

@@ -1,5 +1,7 @@
 /*
  *		fimg-2gray.c
+ *
+ *	This is a tricky job...
  */
 
 #include  <stdio.h>
@@ -15,13 +17,21 @@ 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)
 {
 float		kr, kg, kb, kdiv;
 int		nbb, foo;
 
-kr = kg = kb = 1.0;		/* canonic random values */
+if (k)	{
+	/* some random funky values ...  */
+	kr = 0.789;	kg = 0.523;	kb = 0.349;
+	}
+else	{
+	/* ... and canonic random values */
+	kr = kg = kb = 1.0;
+	}
 kdiv = kr + kg + kb;
 
 /* we must check the validity of our parameters */
@@ -34,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) +
@@ -59,6 +66,10 @@ int fimg_desaturate(FloatImg *src, FloatImg *dst, int notused)
 int		foo, nbb;
 
 /* we must check the validity of our parameters */
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
 if (FIMG_TYPE_RGB != src->type || FIMG_TYPE_RGB != dst->type) {
 	fprintf(stderr, "%s : bad image type\n", __func__);
 	return -18;
@@ -66,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;

lib/fimg-core.c

@@ -39,8 +39,8 @@ return "???";
 /* --------------------------------------------------------------------- */
 int fimg_print_version(int k)
 {
-fprintf(stderr, "*** FloatImg library, alpha %d (%s, %s)\n",
-		FIMG_VERSION, __DATE__, __TIME__);
+fprintf(stderr, "*** FloatImg library, v%d '%s' (%s, %s)\n",
+		FIMG_VERSION, RELEASE_NAME, __DATE__, __TIME__);
 
 if (51 == k) {
 	puts("+------------------------+");
@@ -55,6 +55,7 @@ void fimg_print_sizeof(void)
 {
 fprintf(stderr, "   sz FloatImg =   %lu\n", sizeof(FloatImg));
 fprintf(stderr, "   sz filehead =   %lu\n", sizeof(FimgFileHead));
+fprintf(stderr, "   sz metadata =   %lu\n", sizeof(FimgMetaData));
 fprintf(stderr, "   sz filter   =   %lu\n", sizeof(FimgFilter3x3));
 }
 /* --------------------------------------------------------------------- */
@@ -157,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;
 	}
 

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,"****** %s have metadata\n", fname);
+if ('a' == filehead.magic[4] && verbosity > 1) {
+	fprintf(stderr,"*** %s have metadata\n", fname);
 	}
 
 datas[0] = filehead.w;
@@ -59,7 +59,103 @@ return 0;
 }
 /* ---------------------------------------------------------------- */
 /*
- *	/!\		thi func work ONLY on RGB image
+ *  new avril 2022 : trying to save metadatas...
+ */
+int fimg_dumpmd_to_file(FloatImg *fimg, char *fname,		\
+				FimgMetaData *pmd, int notused)
+{
+FILE		*fp;
+int		foo, nbre;
+FimgFileHead	filehead;
+FimgMetaData	fakemd;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p '%s' %p %d )\n", __func__, fimg,
+						fname, pmd, notused);
+#endif
+
+if (notused) {
+	fprintf(stderr, "%s: notused must be 0, was %d\n", \
+			__func__,			notused);
+	}
+
+if (FIMG_TYPE_RGB != fimg->type) {
+	fprintf(stderr, "%s : bad type %d\n", __func__, fimg->type);
+	return -8;
+	}
+
+/* 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__);
+	foo = fimg_default_metadata(&fakemd, 3);
+	// fprintf(stderr, "fakemd is at %p\n", &fakemd);
+	pmd = &fakemd;
+	}
+else	{
+	/* OK, get some funky metadatas */
+	fprintf(stderr, "%s: acqu fval=%f count=%d\n", __func__,
+				pmd->fval, pmd->count);
+	}
+
+fp = fopen(fname, "w");
+if (NULL==fp) {
+	perror(fname);
+	return -1;
+	}
+
+memset(&filehead, 0, sizeof(filehead));
+memcpy(filehead.magic, "FIMG", 4);
+filehead.w = fimg->width;	filehead.h = fimg->height;
+filehead.t = fimg->type;
+
+/* XXX     metadata */
+if (NULL != pmd) {
+	// fprintf(stderr, "ok, %s give an 'a' flag\n", __func__);
+	filehead.magic[4] = 'a';
+	}
+
+foo = fwrite(&filehead, sizeof(FimgFileHead), 1, fp);
+if (1 != foo) {
+	perror(fname);
+	fclose(fp);
+	/* may be here, we can remove the broken file ? */
+	return -2;
+	}
+
+/* we have metadata, put them on tape */
+if (NULL != pmd) {
+	// fprintf(stderr, ">>> %s write metadata %p\n", __func__, pmd);
+	foo = fwrite(pmd, sizeof(FimgMetaData), 1, fp);
+	if (1 != foo) {
+		perror(fname);
+		fclose(fp);
+		/* may be here, we can remove the broken file ? */
+		return -2;
+		}
+	}
+
+nbre = fimg->width * fimg->height;	/* pixels per frame */
+foo = fwrite(fimg->R, sizeof(float), nbre, fp);
+if (nbre != foo) {
+	perror(fname); fclose(fp); return -3;
+	}
+foo = fwrite(fimg->G, sizeof(float), nbre, fp);
+if (nbre != foo) {
+	perror(fname); fclose(fp); return -3;
+	}
+foo = fwrite(fimg->B, sizeof(float), nbre, fp);
+if (nbre != foo) {
+	perror(fname); fclose(fp); return -3;
+	}
+
+fclose(fp);
+
+return 0;
+}
+/* ---------------------------------------------------------------- */
+/*
+ *	/!\		this func work ONLY on RGB image
  */
 int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused)
 {
@@ -72,16 +168,27 @@ fprintf(stderr, ">>> %-25s ( %p '%s' %d )\n", __func__, fimg,
 						fname, notused);
 #endif
 
-if (3 != fimg->type) {
+if (notused) {
+	fprintf(stderr, "%s: notused must be 0, was %d\n", \
+			__func__,			notused);
+	}
+
+if (FIMG_TYPE_RGB != fimg->type) {
 	fprintf(stderr, "%s : bad type %d\n", __func__, fimg->type);
 	return -8;
 	} 
 
+// fprintf(stderr, "'%s' try to open '%s'\n", __func__, fname);
 fp = fopen(fname, "w");
-if (NULL==fp) {
+// fprintf(stderr, "   fp at %p\n", fp);
+
+if (NULL == fp) {
 	perror(fname);
 	return -1;
 	}
+else	{
+	// fprintf(stderr, "file '%s' opened\n", fname);
+	}
 
 memset(&filehead, 0, sizeof(filehead));
 memcpy(filehead.magic, "FIMG", 4);
@@ -94,6 +201,9 @@ if (1 != foo) {
 	fclose(fp);
 	return -2;
 	}
+// fprintf(stderr, "'%s' write header --> %d\n", __func__, foo);
+
+
 nbre = fimg->width * fimg->height;	/* pixels per frame */
 
 foo = fwrite(fimg->R, sizeof(float), nbre, fp);
@@ -150,7 +260,14 @@ if (	(filehead.w != where->width) ||
 
 /* XXX preparer la gestion des metadata */
 if ('a' == filehead.magic[4]) {
-	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__);
+		perror(fname);
+		exit(1);
+		}
 	}
 
 nbre = filehead.w * filehead.h;		/* number of pixels per frame */
@@ -189,7 +306,8 @@ fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, fname, head);
 
 /*
  *	may be we can crash coredump here if the head
- *	descriptor is not blank ?
+ *	descriptor from caller is not blank ? Or just
+ *	display a warning ?
  */
 
 fp = fopen(fname, "r");
@@ -216,6 +334,23 @@ if (foo) {
 	return foo;
 	}
 
+/* bugfix Sat 14 May 2022 07:02:53 PM CEST */
+/*
+ *	Oh boy, we have to skeep the metadata chunck
+ */
+if ('a' == filehead.magic[4]) {
+	if (verbosity > 1)
+		{ fprintf(stderr, "in %s, %s has metadata\n", __func__, fname); }
+	/* old school processing... 
+	foo = fseek(fp, (long)sizeof(FimgMetaData), SEEK_CUR);
+	*/
+	foo = fread(&head->mdatas, sizeof(FimgMetaData), 1, fp);
+	if (1 != foo) {
+		fprintf(stderr, "%s: shit hit the fan %d\n", __func__, foo);
+		abort();
+		}
+	}
+
 size = filehead.w * filehead.h;
 nbread = 0;
 nbread += fread(head->R, sizeof(float), size, fp);

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])
@@ -144,7 +174,7 @@ for (idx=0; idx<4; idx++) {
 return 0;
 }
 /* ---------------------------------------------------------------- */
-/* d'après Wikipedia Fr :
+/* d'apres Wikipedia Fr :
                         | c = 0
                         | s = x1
                         | pour j de 2 à n
@@ -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;
@@ -296,6 +324,33 @@ if (fi->type == FIMG_TYPE_GRAY) {
 return 0;
 }
 /* ---------------------------------------------------------------- */
+/*				nouveau 17 septembre 2022 */
+int   fimg_div_cste(FloatImg *fi, float value)
+{
+int		nbre, idx;
+
+if ( (fi->type != FIMG_TYPE_RGB) && (fi->type != FIMG_TYPE_GRAY) ) {
+	fprintf(stderr, "%s : type %d invalide\n",
+				__func__, fi->type);
+	return -44;
+	}
+
+nbre = fi->width * fi->height;
+if (fi->type == FIMG_TYPE_RGB) {
+	for (idx=0; idx<nbre; idx++) {
+		fi->R[idx] /= value;
+		fi->G[idx] /= value;
+		fi->B[idx] /= value;
+		}
+	}
+if (fi->type == FIMG_TYPE_GRAY) {
+	for (idx=0; idx<nbre; idx++) {
+		fi->R[idx] /= value;
+		}
+	}
+return 0;
+}
+/* ---------------------------------------------------------------- */
 /*
  *	oh, please explain the usecase of this function !
  */
@@ -303,6 +358,11 @@ int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused)
 {
 double		coef;
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 if (fi->type != FIMG_TYPE_RGB) {
 	fprintf(stderr, "%s : type %d invalide\n",
 				__func__, fi->type);
@@ -324,6 +384,7 @@ if (verbosity) {
 	fprintf(stderr, "image @    %p\n", fi);
 	fprintf(stderr, "fval       %f\n", fi->fval);
 	fprintf(stderr, "count      %d\n", fi->count);
+	fprintf(stderr, "maxima     %f\n", maxima);
 	fprintf(stderr, "coef       %f\n", coef);
 	}
 
@@ -347,7 +408,6 @@ for (idx=0; idx<surface; idx++) {
 return 0;
 }
 /* ---------------------------------------------------------------- */
-
 /*            Warning: this function is _very_ slow                 */
 void fimg_drand48(FloatImg *fi, float kmul)
 {
@@ -363,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;
 	}
-
 }
 /* ---------------------------------------------------------------- */
 

lib/fimg-pnm.c

@@ -23,9 +23,14 @@ int fimg_load_from_pnm(char *fname, FloatImg *head, int notused)
 FILE		*fp;
 int		width, height, maxval;
 int		foo, line, column;
-unsigned char	*buffline, *idxrd, dummychar;
+unsigned char	*buffline, *idxrd;
 float		*Rptr, *Gptr, *Bptr;
 
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+
 if (NULL==head) {
 	fprintf(stderr, "%s : head ptr is %p\n", __func__, head);
 	return -8;
@@ -58,6 +63,7 @@ if (foo) {
         }
 
 #if DEBUG_LEVEL
+unsigned char dummychar;
 fread(&dummychar, 1, 1, fp);
 fprintf(stderr, "%s : dummychar %xx\n", __func__, dummychar);
 #else

lib/fimg-timers.c

@@ -24,6 +24,8 @@ double fimg_timer_set(int whot)
 {
 double		current;
 
+if (whot) fprintf(stderr, "in %s whot is %d\n", __func__, whot);
+
 current = dtime();
 
 #if DEBUG_LEVEL
@@ -36,6 +38,9 @@ return memory_time;
 double fimg_timer_get(int whot)
 {
 double		current;
+
+if (whot) fprintf(stderr, "in %s whot is %d\n", __func__, whot);
+
 current = dtime();
 return current - memory_time;
 }

lib/interpolate.c

@@ -49,6 +49,14 @@ fprintf(stderr, ">>> %s ( %p %p %p %f )\n", __func__,
 				s1, s2, d, coef);
 #endif
 
+/* sanity check here ? or may be ask the
+   caller to do it himself ?
+*/
+if ( (coef < 0.0) || (coef >= 1.0) ){
+	fprintf(stderr, "%s: coef %f out of range\n", __func__, coef);
+	return -8;
+	}
+
 foo = fimg_images_not_compatible(s1, s2);
 if (foo) {
 	fprintf(stderr, "compat s1 s2 -> %d\n", foo);
@@ -66,6 +74,9 @@ switch (s1->type) {
 		gray_interpolate (s1, s2, d, coef);	break;
 	case FIMG_TYPE_RGB:
 		rgb_interpolate  (s1, s2, d, coef);	break;
+	case FIMG_TYPE_RGBA:
+		fprintf(stderr, "WTF?\n");
+		return -18;
 	default:
 		fprintf(stderr, "%s, %d is a bad type\n", __func__, s1->type);
 		return -18;

lib/metadata.c

@@ -1,12 +1,19 @@
 /*
  *              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>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <unistd.h>
-#include  "string.h"
+#include  <time.h>
+#include	<sys/time.h>
+#include  <string.h>
 
 #include  "../floatimg.h"
 
@@ -15,29 +22,143 @@ extern int verbosity;           /* must be declared around main() */
 /* ---------------------------------------------------------------- */
 int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused)
 {
+int		foo;
+double		doubletime;
 
+#if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p '%s' 0x%08x )\n", __func__,
 				pmd, title, notused);
+#endif
 
-fprintf(stderr, "sizeof metadata     = %ld\n", sizeof(FimgMetaData));
-fprintf(stderr, "magic               = '%8s'\n", pmd->magic);
-/* TIMESTAMP HERE */
-fprintf(stderr, "counter             = %d\n", pmd->count);
-fprintf(stderr, "float value         = %.3f\n", pmd->fval);
-fprintf(stderr, "id camera           = '%s'\n", pmd->idcam);
-fprintf(stderr, "origin              = %d\n", pmd->origin);
+if (notused) {
+	fprintf(stderr, "notused was %d, must be 0 in %s\n",
+				notused, 		__func__);
+	}
+if (NULL != title) {
+	fprintf(stderr, "======== metadata for %s\n", title);
+	}
+if (verbosity) {
+	fprintf(stderr, "sizeof(metadata)     = %ld\n",    \
+				sizeof(FimgMetaData));
+	fprintf(stderr, "    Magic [%08x]\n", pmd->magic);
+	}
 
-return -1;
+/* SHOW TIMESTAMP HERE */
+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;
+fprintf(stderr, "dtime of day         = %12.3f\n", doubletime);
+fprintf(stderr, "creator pid          = %ld\n", pmd->cpid);
+fprintf(stderr, "float value          = %.3f\n", pmd->fval);
+fprintf(stderr, "counter              = %d\n", pmd->count);
+fprintf(stderr, "id camera            = '%s'\n", pmd->idcam);
+fprintf(stderr, "origin               = 0x%x\n", pmd->origin);
+
+fputs("reserved words are:\n      ", stderr);
+for (foo=0; foo<8; foo++) {
+	fprintf(stderr, "     0x%08x", pmd->reserved[foo]);
+	if (3 == foo) fputs("\n      ", stderr);
+	}
+fputc('\n', stderr);
+return 0;
 }
 /* ---------------------------------------------------------------- */
-int fimg_default_metadata(FimgMetaData *pmd)
+/*
+ *	those values may be loaded from a config file ?
+ */
+int fimg_default_metadata(FimgMetaData *pmd, int bla)
 {
+int			foo;
+struct timeval		tvl;
 
-memcpy(pmd->magic, "metadata", 8);
-pmd->count    = 0;
-pmd->fval     = 255.0;
-strcpy(pmd->idcam, "unknow");
-pmd->origin   = 999;
-return -1;
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pmd, bla);
+#endif
+
+memset(pmd, 0, sizeof(FimgMetaData));
+
+/* set timestamp here ? */
+/* CHALLENGE ACCEPTED */
+memset(&tvl, 0, sizeof(struct timeval));
+foo = gettimeofday(&tvl, NULL);
+if (foo) {
+	/* error on get time of day ? */
+	perror("omg");
+	}
+else	{
+	if (verbosity > 1) {
+		fprintf(stderr, "%s : set TimeOfDay to  %12ld %8ld\n", \
+					__func__, tvl.tv_sec, tvl.tv_usec);
+		}
+	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 camera>");
+pmd->origin        = 0xdeadbeef;	// classic joke, sorry
+pmd->reserved[0]   = bla;
+pmd->reserved[7]   = 0x55445544;	// magic number is a crime
+
+return 0;
+}
+/* ---------------------------------------------------------------- */
+int fimg_get_metadata_from_file(char *fname, FimgMetaData *pmd)
+{
+FILE			*fp;
+FimgFileHead		filehead;
+FimgMetaData		metadata;
+int			foo;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, fname, pmd);
+#endif
+
+if (NULL==(fp=fopen(fname, "r"))) {
+	perror(fname);
+	return -1;
+	}
+
+foo = fread(&filehead, sizeof(FimgFileHead), 1, fp);
+if (1 != foo) {
+	fprintf(stderr, "short read (%d) on %s (head)\n", foo, fname);
+	fclose(fp);
+	return -2;
+	}
+
+if (memcmp(filehead.magic, "FIMG", 4)) {
+	fprintf(stderr, "'%s' is not a fimg file.\n", fname);
+	fclose(fp);
+	return -3;
+	}
+
+if ('a' != filehead.magic[4]) {
+	fprintf(stderr, "file '%s' have no metadata.\n", fname);
+	fclose(fp);
+	return -4;
+	}
+
+foo = fread(&metadata, sizeof(FimgMetaData), 1, fp);
+if (1 != foo) {
+	fprintf(stderr, "short read on %s (metadata)\n", fname);
+	fclose(fp);
+	return -5;
+	}
+
+fclose(fp);		/* got all needed datas */
+
+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;
 }
 /* ---------------------------------------------------------------- */

lib/t.c

@@ -22,11 +22,21 @@ int			foo;
 
 fprintf(stderr, "-------- %s ( %s ) --------\n", __func__, fname);
 
-foo = fimg_default_metadata(&Md);
+foo = fimg_default_metadata(&Md, 0);
+foo = fimg_show_metadata(&Md, "default from t.c", 0);
 
-foo = fimg_show_metadata(&Md, "from t.c", 0);
+foo = fimg_get_metadata_from_file(fname, &Md);
+fprintf(stderr, "%s : get metadata -> %d\n", fname, foo);
+if (foo) {
+	return foo;
+	}
 
-return -1;
+foo = fimg_show_metadata(&Md, fname, 0);
+if (foo) {
+	fprintf(stderr, "%s: show metadata -> %d\n", __func__, foo);
+	return foo;
+	}
+return 0;
 }
 /* ---------------------------------------------------------------- */
 int essai_save_plane(int wot)
@@ -75,6 +85,11 @@ fprintf(stderr, "   %f      %f\n", A, B);
 return 0;
 }
 /* ---------------------------------------------------------------- */
+int essai_alphachan(void)
+{
+
+return -1984;
+}
 /* ---------------------------------------------------------------- */
 #define  WI	1024
 #define  HI	768
@@ -85,14 +100,15 @@ int essai_interpolate(int k)
 FloatImg	A, B, C;
 int		foo, idx;
 char		ligne[200];
-float		fval, minmax[6];
+float		fval;
 
 foo = fimg_create(&A, WI, HI, FIMG_TYPE_RGB);
 if (foo) {
 	fprintf(stderr, "%s err create A %d\n", __func__, foo);
 	return foo;
 	}
-fimg_hdeg_a(&A, KDEG);
+if (k)	fimg_hdeg_a(&A, KDEG);
+else	fimg_vdeg_a(&A, KDEG);
 
 foo = fimg_create(&B, WI, HI, FIMG_TYPE_RGB);
 if (foo) {
@@ -289,6 +305,12 @@ fimg_save_as_pnm(&copy, "cos_010.pnm", 0);
 fimg_destroy(&dessin);		fimg_destroy(&copy);
 
 return 0;
+}
+/* ---------------------------------------------------------------- */
+void help_me_obiwan(void)
+{
+
+
 }
 /* ---------------------------------------------------------------- */
 int main(int argc, char *argv[])
@@ -297,9 +319,10 @@ int		foo, opt;
 // char		outname[100];
 int		gray = 0;
 
-while ((opt = getopt(argc, argv, "gn:v")) != -1) {
+while ((opt = getopt(argc, argv, "ghn:v")) != -1) {
 	switch(opt) {
 		case 'g':	gray++;			break;
+		case 'h':	help_me_obiwan();	break;
 		case 'n':	foo=atoi(optarg);	break;
 		case 'v':	verbosity++;		break;
 		default:
@@ -314,7 +337,7 @@ if (verbosity)	{
 	fimg_print_sizeof();
 	}
 
-foo = essai_metadata("foo.fimg");
+foo = essai_metadata("quux.fimg");
 fprintf(stderr, "retour essai  -> %d\n", foo);
 
 // foo = essai_save_plane(0);

scripts/.gitignore

@@ -0,0 +1,7 @@
+
+
+*.fits
+*.tiff
+*.tif
+*.png
+

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.
 

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
+

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"
+

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
+