check for the export directory (singlepass)

.gitignore

@@ -8,8 +8,12 @@ lib/*.gif
 
 *.a
 gmon.out
+cscope.out
+
+*.swp
 
 *.pnm
+*.pgm
 *.fimg
 essai
 MANIFEST
@@ -26,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
@@ -50,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
@@ -79,9 +58,4 @@ Fonderie/singlepass
 Fonderie/crapdef.h
 Fonderie/crapstr.h
 
-experiment/assemblage
-experiment/extracteur
-experiment/*.fimg
-experiment/*.pnm
-experiment/*.o
 

Fonderie/Makefile

@@ -7,11 +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
 
@@ -40,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
@@ -70,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
+le second (interpolator) fait un fondu-enchainé de N pas
-entre deux images consécutives.
+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)
+Ces filtres ont chacun un nom, utilisable dans une chaine de filtres. 
-utiliser indistinctement 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,
+classique dans notre univers, en fait.
-on doit continuer à appeler les filtres par leur numéro, jdçjdr.
 
-`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
+        -E foo:bla:kr   input  filter chain
-        -F name:j       output 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,9 +5,9 @@
 #		is includet by 'crapulator.c'
 #
 BEGIN	{
-	print "// -----------------------------------"
+	print "// -------------------------------------"
-	print "// generated file, do not edit by hand";
+	print "// generated file, do not edit by hand !";
-	print "// -----------------------------------"
+	print "// -------------------------------------"
 	print "Crapulor  CrapL[] = {";
 	}
 
@@ -16,12 +16,13 @@ BEGIN	{
 #		$3 and $4 are two not used parameters
 #
 	{
-	printf "   { CR_%s, \"%s\", %d, %f }, // id=%d\n",
+	name = sprintf("CR_%s", $2)
-                        $2,    $2,   $3, $4,           $1;
+	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

@@ -4,6 +4,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 #include  <unistd.h>
 
@@ -81,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,
@@ -90,7 +91,8 @@ FimgFilter3x3	lowpass = {
 	16.0,	0.0
 	};
 
-FimgFilter3x3	hipass = {
+static FimgFilter3x3	hipass = {
+	/* there was a bug with this filter */
 		{
 		-1.0,	-1.0,	-1.0,
 		-1.0,	 9.0,	-1.0,
@@ -99,11 +101,12 @@ FimgFilter3x3	hipass = {
 	1.0,	0.0
 	};
 
-FimgFilter3x3	diagonal = {
+static FimgFilter3x3	diagonal = {
+	/* there was a bug with this filter */
 		{
-		2.0,	1.0,	0.0,
+		4.0,	1.0,	0.0,
 		1.0,	0.0,	-1.0,
-		0.0,	-1.0,	-2.0,
+		0.0,	-1.0,	-4.0,
 		},
 	1.0,	0.0
 	};
@@ -151,6 +154,150 @@ fimg_destroy(&img);
 return retval;
 }
 /* -------------------------------------------------------------- */
+int run_killrgb_0(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+
+// fprintf(stderr, "----> %s\n", __func__);
+
+memset(&tmp, 0, sizeof(FloatImg));
+
+fimg_clone(img, &tmp, 0);
+ret = fimg_killrgb_v(img, &tmp, k);
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
+// fprintf(stderr, "%s ---->\n", __func__);
+
+return ret;
+}
+/* -------------------------------------------------------------- */
+static int run_pixelize_0(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+ret = fimg_pixelize_h_0(img, &tmp, k);
+fimg_copy_data(&tmp, img);
+fimg_destroy(&tmp);
+
+return ret;
+}
+/* -------------------------------------------------------------- */
+static int run_pixelize_random(FloatImg *img, int k)
+{
+FloatImg		tmp;
+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);
+
+return ret;
+}
+/* -------------------------------------------------------------- */
+static int run_decomprgbz_color(FloatImg *img, int k)
+{
+FloatImg		tmp;
+int			ret;
+
+memset(&tmp, 0, sizeof(FloatImg));
+fimg_clone(img, &tmp, 0);
+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;
+}
+/* -------------------------------------------------------------- */
+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;
+}
+/* -------------------------------------------------------------- */
 /*
  *	This is the main filter engine used both for input and
  *	output processing. It can be called by the filterstack
@@ -269,19 +416,28 @@ switch (idFx) {
 		retval = fimg_power_2(image, image, 1000.0);
 		break;
 
+	case CR_triplemul:
+		retval = fimg_sfx_triplemul(image, image, 0);
+		break;
+
 	/* here are the glitches */
 	case CR_bsombra:			/* experiment ! */
 		retval = des_bords_sombres_a(image, 160);
 		break;
 	case CR_bsombrb:			/* experiment ! */
-		retval = des_bords_sombres_b(image, 160);
+		retval = des_bords_sombres_b(image, 120);
 		break;
+
 	case CR_vsglitch:
 		/* please make this function more tweakable */
 		retval = vertical_singlitch(image, 290+rand()%45,
 						fval, 0.19, 0);
 		break;
 
+	case CR_crumphard:	/* new june 1st 2021, in the bibcave */
+		retval = fimg_crump_hard(image, image, fval, 0);
+		break;
+
 	case CR_rndblks:
 		retval = random_blocks(image, 70);
 		break;
@@ -298,22 +454,72 @@ 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;
 
+	case CR_killrgb0:
+		retval = run_killrgb_0(image, 0);
+		break;
+
+	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, 16);
+		break;
+
+	case CR_splitlevel:
+		retval = fimg_split_level(image, image, 0);
+		break;
+
+	case CR_decrgbzc:
+		retval = run_decomprgbz_color(image, 0);
+		break;
+	case CR_decrgbzg:
+		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);
@@ -349,14 +555,26 @@ void list_crapulors(char *texte)
 int		idx;
 
 #define OUT	stdout
-fprintf(OUT, "______________. %s\n", texte);
+
+if (verbosity) {
+	fprintf(stderr, "We have around %ld filters now !\n", NBCRAP);
+	}
+
+if (NULL!=texte && verbosity)
+	fprintf(OUT, " _________ %s _________\n", texte);
+
 for (idx=0; CrapL[idx].id!=-1; idx++) {
+	if (verbosity) {
 		fprintf(OUT, " %-12s | %4d  |  %5d  |  %8.3f\n",
 					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

@@ -27,10 +27,26 @@
 26	rndblks		1	1.0
 27	shiftln0	1	1.0
 28	qsortrgb	2	1.0
+29	triplemul	3	1.0
 30	multidots	100	1.333
 31	diagonal	1	1.0
 32	vsglitch	1	1.0
+33	crumphard	1	1.0
 42	nothing		42	3.1415926
+43	killrgb0	1	9
 45	hilightr	1	1.717
-99	message		1	1.0
+46	pixelizh	1	1.111
+47	pixelizv	1	1.111
+48	pixelrand	1	1
+49	splitlevel	1	1
+50	decrgbzc	1	99
+51	decrgbzg	1	99
+60	gr2popcol	1	99
+61	fluffy		1	0.12
+62	suprbg		1	0
+80	thermocol	1	0
+81	triptyq		1	0
+90	togray		1	0
+91	shift0		1	0
 -1	end		1	1.0
+

Fonderie/fifo.c

@@ -5,6 +5,7 @@
  */
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
 #include  <stdlib.h>
 #include  <malloc.h>
 
@@ -25,7 +26,7 @@ extern	int		verbosity;
 static	A_Fifo		g_fifo;
 
 /* -------------------------------------------------------------- */
-static int big_adder(FloatImg *from, FloatImg *to)
+static inline int big_adder(FloatImg *from, FloatImg *to)
 {
 int		size, idx;
 
@@ -86,10 +87,10 @@ 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, step);
+fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
 #endif
 
 foo = faire_la_somme(&g_fifo, NULL, 1);
@@ -117,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/filterstack.c

@@ -4,6 +4,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 #include  <ctype.h>
 #include  <alloca.h>

Fonderie/fonderie.c

@@ -4,11 +4,13 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <glob.h>
 #include  "../floatimg.h"
 
+#include  "utilfuncs.h"
 #include  "fifo.h"
 #include  "glitches.h"
 #include  "crapulator.h"
@@ -107,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);
 
@@ -119,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);
@@ -185,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);
 }
 /* -------------------------------------------------------------- */
@@ -199,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) {
@@ -228,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);
 		}
 	}
 
@@ -236,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);
@@ -257,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

@@ -7,6 +7,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 #include  <math.h>
 
@@ -150,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 (y=16; y<picture->height-16; y+=16) {
-	for (x=0; x<picture->width; x+=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

@@ -10,12 +10,14 @@
  */
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <glob.h>
 
 #include  "../floatimg.h"
 
+#include  "utilfuncs.h"
 #include  "fifo.h"
 #include  "glitches.h"
 #include  "crapulator.h"
@@ -53,10 +55,14 @@ char		*filename;
 IdxValue	*idxvalues;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, ptr_glob,
+fprintf(stderr, ">>> %s ( %p %p %d %p)\n", __func__, ptr_glob,
-				ptr_idxval, method);
+				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 */
@@ -65,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;
@@ -103,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;
 }
@@ -121,7 +127,7 @@ 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? */
 
@@ -135,8 +141,8 @@ foo = glob(pattern, 0, NULL, &globbuf);
 fprintf(stderr, "    globbing '%s' -> %d, %d files found\n",
 			pattern, foo, (int)globbuf.gl_pathc);
 if (0 == globbuf.gl_pathc) {
-	fprintf(stderr, "%s : no file found, aborting\n", __func__);
+	fprintf(stderr, "%s : no file found, ABEND\n", __func__);
-	return -1;
+	exit(1);
 	}
 
 idx_values = NULL;
@@ -154,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);
@@ -171,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;
 
 	/* here was the input filter */
 	foo = filterstack_run(0, &B, 0);
@@ -235,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) {
+if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
-	list_crapulors("available filters");
-	}
 
 exit(0);
 }
@@ -252,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 */
@@ -274,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);
 		}
 	}
 
@@ -286,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);
@@ -302,13 +320,14 @@ 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) {
-	puts("=========================");
+	fputs("=========================\n", stderr);
 	filterstack_list(0, __FILE__);
 	filterstack_list(1, __FILE__);
-	puts("=========================");
+	fputs("=========================\n", stderr);
 	}
 
 nbrsteps = atoi(argv[optind+2]);

Fonderie/metriques.c

@@ -4,6 +4,8 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
+
 #include  "../floatimg.h"
 #include  "metriques.h"
 
@@ -84,6 +86,9 @@ for (idx=20; idx < size; idx+=42) {
 return 0;
 }
 /*   --------------------------------------------------------------   */
+/*
+ *		LR mean left/right
+ */
 int get_float_metric_LR(FloatImg *pimg, float *where)
 {
 int	coords[4], foo;
@@ -95,8 +100,16 @@ coords[2] = pimg->width / 2;		//  W
 coords[3] = pimg->height;		//  H
 
 foo = stat_zone(pimg, coords, valL);
+if (foo) {
+	fprintf(stderr, "err %d stat zone in %s\n", foo, __func__);
+	return foo;
+	}
 coords[1] = pimg->width / 2;
 foo = stat_zone(pimg, coords, valR);
+if (foo) {
+	fprintf(stderr, "err %d stat zone in %s\n", foo, __func__);
+	return foo;
+	}
 
 *where = valL[1] - valR[1];
 

Fonderie/sfx.c

@@ -5,6 +5,7 @@
  */
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
 #include  <stdlib.h>
 #include  <malloc.h>
 #include  <math.h>
@@ -20,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 !
@@ -46,21 +129,47 @@ return -1;
 }
 /* -------------------------------------------------------------- */
 /* nouveau du premier dimanche de 2020 'nextgen'		*/
+
+/*		CE TRUC NE MARCHE PAS COMME PRÉVU */
+
 static int pixel_trinitron(FloatImg *pimg, int pos[4], float *fvals)
 {
 int		x, y, pline, off;
+int		ym;
 
-for (y=pos[1]; y<pos[1]+pos[3]; y++) {
+// 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;
+
+#define  FDIM  0.60
+
+for (y=pos[1]; y<ym; y++) {
 	pline = y*pimg->width;
-	for (x=pos[0]+2; x<pos[0]+pos[2]-2; x++) {
+	for (x=0; x<5; x++) {
-		off = pline + x;
+		off = pline + (x+pos[0]);
+
+		/* wtf i'm doing here ? */
+		if ( (pos[1]==y) || (ym-1==y) ) {
+			pimg->R[off]    = fvals[0] * FDIM;
+			pimg->G[off+5]  = fvals[1] * FDIM;
+			pimg->B[off+10] = fvals[2] * FDIM;
+			}
+		else	{
 			pimg->R[off]    = fvals[0];
-		pimg->G[off] = fvals[1];
+			pimg->G[off+5]  = fvals[1];
-		pimg->B[off] = fvals[2];
+			pimg->B[off+10] = fvals[2];
+			}
 		}
 	}
 return 0;
 }
+
+/*
+ *	need more explanation, need more work
+ */
 int trinitron(FloatImg *pimg, int notused)
 {
 int		x, y, coo[4], foo;
@@ -70,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;
 }
 /* -------------------------------------------------------------- */
@@ -311,19 +436,40 @@ return 0;
 /* -------------------------------------------------------------- */
 /* nouveau Mon 10 May 2021 08:46:02 PM CEST
  *	chez Eric 1KA						*/
-int des_bords_sombres_b(FloatImg *pimg, int offset)
+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
 
-if (offset<0 || offset>=pimg->width) {
+for (idx=0; idx<nbre; idx++) {
-	fprintf(stderr, "%s: offset %d is bad\n", __func__, offset);
+
-	return -66;
+	coef = (float)idx / (float)nbre;
+
+	fptr = pimg->R + (idx*pimg->width);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+	fptr = pimg->G + (idx*pimg->width);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+	fptr = pimg->B + (idx*pimg->width);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+
+	foo = (pimg->height-idx) - 1;
+	fptr = pimg->R + (foo*pimg->width);
+	// fprintf(stderr, "%5d   %9.3f    %p\n", foo, coef, fptr);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+	fptr = pimg->G + (foo*pimg->width);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+	fptr = pimg->B + (foo*pimg->width);
+	for (x=0; x<pimg->width; x++) *fptr++ *= coef;
+
 	}
 
-return -1;
+// fprintf(stderr, "WARNING: %s badly implemented\n", __func__);
+
+return 0;
 }
 /* -------------------------------------------------------------- */
 /*

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

@@ -1,5 +1,6 @@
 /*
-		SINGLE
+		SINGLE PICZ PROCESSOR
+
 	experimental and/or testing code, do not use in
 	production.
 
@@ -8,6 +9,8 @@
 #include   <stdio.h>
 #include   <string.h>
 #include   <sys/stat.h>
+#include   <stdint.h>
+#include  <sys/time.h>
 
 #include   "../floatimg.h"
 
@@ -23,7 +26,7 @@
 static int		nextpng, counter;
 static char		*destination;
 static int		chainfilter;
-static int		outtype;
+// static int		outtype;
 
 /*		and the classic global var			*/
 extern int		verbosity;
@@ -48,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;
 	}
 
@@ -98,7 +101,6 @@ fprintf(stderr, "%s : %s\n", __FILE__, title);
 fprintf(stderr, "   nextpng          %d\n", nextpng);
 fprintf(stderr, "   counter          %d\n", counter);
 fprintf(stderr, "   chainfilter      %d\n", chainfilter);
-
 fprintf(stderr, "   destination      %s\n", destination);
 
 if (k) {

Fonderie/singlepass.c

@@ -6,12 +6,14 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <unistd.h>
 #include  <string.h>
 #include  <glob.h>
 
 #include  "../floatimg.h"
 
+#include  "utilfuncs.h"
 #include  "crapulator.h"
 #include  "filterstack.h"
 #include  "single.h"
@@ -24,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)
 {
@@ -34,11 +39,11 @@ char		*fname;
 double		elapsed;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' '%s' %d %d )\n", __func__,
+fprintf(stderr, ">>> %s ( '%s' '%s'  %d  %d %d )\n", __func__,
-				globber, destdir, fchain, outfmt);
+				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);
 
@@ -80,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) {
+	if (0==idx && verbosity) {
-		fprintf(stderr, "image size %dx%d\n",
+		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) {
@@ -106,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);
-			}
 		}
 	}
 
@@ -118,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",
@@ -155,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]);
@@ -187,7 +192,6 @@ while ((opt = getopt(argc, argv, "hF:g:LO:r:svx")) != -1) {
 			fprintf(stderr, "%s ABEND\n", argv[0]);
 			exit(1);
 		}
-
 	}
 
 if (repeat < 1) {
@@ -195,6 +199,13 @@ if (repeat < 1) {
 	exit(2);
 	}
 
+foo = check_if_export_dir_is_valid(outdir, 0);
+if ( !foo ) {
+	fprintf(stderr, "** export dir (%s) not valid\n", outdir);
+	fprintf(stderr, "** may be you have to create it ?\n");
+	exit(1);
+	}
+
 foo = parse_filter_chain(FILTERS, filterchain);
 if (foo) {
 	fprintf(stderr, "err %d in parse_filter_chain\n", foo);
@@ -211,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

@@ -4,6 +4,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <unistd.h>
 #include  <string.h>
 #include  <glob.h>
@@ -15,6 +16,8 @@
 #include  "crapulator.h"
 #include  "single.h"
 
+#include  "utilfuncs.h"
+
 /* ----------------------------------------------------------- */
 
 int		verbosity;
@@ -27,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)
@@ -35,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);
 	}
 
@@ -72,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)
 {
@@ -160,23 +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\n", __func__, foo);
+	fprintf(stderr, "%s: err %d on create_from_dump\n",
+			__func__, foo);
 	return -1;
 	}
 
-foo = fimg_clone(&image, &dest, 1);
+foo = fimg_clone(&image, &dest, 0);
-foo = fimg_copy_data(&image, &dest);
 
-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);
 
@@ -218,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 -fpic -g -pg  -no-pie -DDEBUG_LEVEL=0
+COPT = -Wall -Wextra -fpic -g  -no-pie -DDEBUG_LEVEL=0
-LDOPT = libfloatimg.a -pg -lm 
+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)
@@ -15,14 +14,27 @@ pour les codeurs.
 Le service après-vente est (plus ou moins bien) assuré sur
 la [mailing list](https://lists.tetalab.org/mailman/listinfo/tetalab) et/ou
 le canal IRC #tetalab sur le réseau de 
-[Freenode](https://webchat.freenode.net/)...
+[Libera.Chat](https://libera.chat/)...
 
 Par ailleurs, d'autres expérimentations sont
 [en cours](http://la.buvette.org/photos/cumul/fonderie/vidz.html#interpolator)
 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,13 +49,34 @@ 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, du
+genre que c'est la deuxième fois que ça m'arrive.
+
+```
+E: Unable to locate package libv4l2-dev
+E: Unable to locate package libnetpbm-dev
+```
+
+Ensuite, j'ai dans l'idée de construire
+um meta-packet à la sauce Debian pour installer facilement tout ce
+qui sert à faire fonctionner ce kluge. Ensuite, j'irais voir du
+coté de pkg-config.
 
 Certains outils externes sont aussi utiles :
 
-- gnuplot
+- gnuplot, pour analyser des données,
-- ImageMagick
+- ImageMagick, parce que Brunus aime ça,
-- LaTeX
+- LaTeX, pour la (trop maigre) documentation.
 
 ## Documentation
 
@@ -51,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

@@ -0,0 +1,18 @@
+
+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

@@ -0,0 +1,14 @@
+# Contributions
+
+## fimg2povhf
+
+Need some external garbage, sorry.
+
+## 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.
+
+
+

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

contrib/fimg2povhf.c

@@ -0,0 +1,116 @@
+/*
+ *		convertir une image flottante en champ d'altitude
+ *
+ *	nouveau 64 ernest renan - 20220108
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <math.h>
+
+#include  "tthimage.h"
+#include  "floatimg.h"
+
+int		verbosity;
+
+/* ------------------------------------------------------------------ */
+int This_is_the_real_conversion(FloatImg *fimg, Image_Desc *hf, int k)
+{
+int			foo;
+float			minmax[6];
+int			x, y, h;
+float			rgb[6], cumul;
+float			maxi;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %d  )\n", __func__, fimg, hf, k);
+#endif
+
+foo = fimg_get_minmax_rgb(fimg, minmax);
+// fimg_print_minmax(minmax, "source");
+
+maxi = 0.0;
+
+for (y=0; y<fimg->height; y++) {
+	for (x=0; x<fimg->width; x++) {
+		foo = fimg_get_rgb(fimg, x, y, rgb);
+		/* non-magic nuabmer spotted */
+		cumul = 1.732 * (rgb[1] + rgb[3] + rgb[5]);
+		if (cumul > maxi) maxi = cumul;
+		h = (int)cumul;
+		foo = Image_hf15_plot(hf, x, y, h);
+		}
+	}
+
+fprintf(stderr, "--- the critical maximum is %f\n", maxi);
+
+return FULL_NUCKED;
+}
+/* ------------------------------------------------------------------ */
+int Convertir_Fimg_to_Povhf(char *fimgname, char *hfname, int k)
+{
+FloatImg		fimg;
+Image_Desc		*hf;
+int			wid, hei;
+int			foo;
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %s %s %d  )\n", __func__, fimgname, hfname, k);
+#endif
+
+foo = fimg_create_from_dump(fimgname, &fimg);
+fprintf(stderr, "load of %s --> %d\n", fimgname, foo);
+if (foo) {
+	return foo;
+	}
+
+wid = fimg.width;  hei = fimg.height;		// nice alias
+fprintf(stderr, "   source picture size %dx%d\n", wid, hei);
+
+hf = Image_alloc(wid, hei, IMAGE_RGB);
+fprintf(stderr, "hf alloc -> %p\n", hf);
+if (NULL == hf) {
+	return NULL_POINTER;
+	}
+
+foo = This_is_the_real_conversion(&fimg, hf, k);
+fprintf(stderr, "real conversion -> %d\n", foo);
+
+foo = Image_TGA_save(hfname, hf, 0);
+fprintf(stderr, "export as tga  -> %d\n", foo);
+
+return FULL_NUCKED;
+}
+/* ------------------------------------------------------------------ */
+void help(int nu)
+{
+printf("usage :\n");
+printf("\t$ fimg2povhf src.fimg dst.tga\n");
+}
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+int		foo;
+
+verbosity = 1;
+
+// printf("%s: argc = %d\n", argv[0], argc);
+
+if (3 != argc) {
+	help(0);
+	exit(0);
+	}
+
+if (verbosity > 1) {
+	Image_print_version(3);
+	fimg_print_version(3);
+	}
+
+foo = Convertir_Fimg_to_Povhf(argv[1], argv[2], 0);
+fprintf(stderr, "retour conversion was %d\n", foo);
+
+fprintf(stderr, "end\n\n");
+return 0;
+}
+
+/* ------------------------------------------------------------------ */

contrib/raytrace.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+src="/dev/shm/foo.fimg"
+dst="hf.tga"
+TMPDIR=${HOME}/TMP
+
+POVOPT="-w512 -h342 +q9 -a "
+
+rm $TMPDIR/hf???.png
+
+for idx in $(seq 0 60)
+do
+
+	echo "========================== " $idx
+
+	grabvidseq -v				\
+		-d /dev/video0 -s 640x480	\
+		-n 60 -p 1.0			\
+		-o ${src} 
+
+	./fimg2povhf $src $dst
+
+	out=$(printf "%s/hf%03d.png" $TMPDIR $idx)
+	echo "raytracing   " ${POVOPT} $out
+	povray -iscene.pov ${POVOPT}  -o${out} 2> pov.stderr
+	# tail -15 pov.stderr
+
+done
+
+convert -delay 10 -colors 240 $TMPDIR/hf???.png foo.gif
+

contrib/scene.pov

@@ -0,0 +1,41 @@
+
+/*    scene demo conversion floatimg -> height field  */
+
+#version 3.7;
+
+global_settings {
+  ambient_light rgb <0.07, 0.07, 0.07>
+  assumed_gamma 1.0
+  }
+
+#include  "colors.inc"
+
+height_field {
+	tga "hf.tga"
+	smooth
+	pigment { color Orange*0.7  }
+	translate <-0.5, 0, -0.5>
+	// scale 2
+	translate y*0.002
+	}
+
+camera	{
+	location	<-0.86, 4, -6.20>
+	look_at		<0, 0, 0>
+	angle		14
+	}
+
+plane {
+ <0, 1, 0>, 0
+ pigment {
+   hexagon 
+   pigment { color Gray20 },
+   pigment { color Gray10 },
+   pigment { color Gray30 }
+   }
+  scale 0.27
+ }
+
+
+light_source { <-9, 2,  3> color White }
+

doc/mkgraf.sh

@@ -1,7 +1,14 @@
 #!/bin/bash
 
+#
+#	this script generate some picz for the PDF documentation
+#	and was called by mkdoc.sh
+#
+
 PI=" 3.141592654 "
 
+#	---------------------------------------------------
+
 OUT="cos01.tex"
 
 gnuplot << __EOF__
@@ -24,6 +31,8 @@ __EOF__
 
 wc $OUT
 
+#	---------------------------------------------------
+
 OUT="cos010.tex"
 
 gnuplot << __EOF__
@@ -45,3 +54,5 @@ plot					\
 __EOF__
 
 wc $OUT
+
+#	---------------------------------------------------

essai.c

@@ -5,6 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <unistd.h>
 #include  <math.h>
 #include  <string.h>
@@ -17,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);
 }
 /* --------------------------------------------------------------------- */
@@ -33,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;
 		}
 	}
@@ -56,7 +60,7 @@ fimg_drand48(&fimgB, 100.0);
 foo = fimg_dump_to_file(&fimgB, "B.fimg", 0);
 
 fimg_timer_set(0);
-#define NBP 500
+#define NBP 5
 for (foo=0; foo<NBP; foo++) {
 	if (verbosity) {
 		printf("%5d     / %5d\n", foo, NBP);
@@ -66,9 +70,9 @@ for (foo=0; foo<NBP; foo++) {
 	// fimg_mul(&fimgA, &fimgB, &fimgA);
 	}
 tb = fimg_timer_get(0);
-fprintf(stderr, "%s = %f seconds\n", __func__, tb);
+fprintf(stderr, "%s = %.2f seconds, %.2f s/p\n", __func__, tb, tb/(double)NBP);
-foo = fimg_save_as_pnm(&fimgA, "drand48.pnm", 0);
+foo = fimg_save_as_pnm(&fimgA, "out.pnm", 0);
-foo = fimg_dump_to_file(&fimgA, "drand48.fimg", 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

@@ -1,15 +1,40 @@
 
-#  experiments
+#
+#  some ugly experiments, do not use in production
+#
 
-
+COPT = -Wall -Wextra -fpic -g -DDEBUG_LEVEL=0 -lm
-COPT = -Wall -fpic -g -DDEBUG_LEVEL=1 -lm
 DEPS = ../floatimg.h  ../libfloatimg.a Makefile
-LIBS = -ltiff -lpnglite -lcfitsio
+LIBS = ../libfloatimg.a -ltiff -lpnglite -lcfitsio -lm
 
-all:	assemblage extracteur
+all:	assemblage muxplanes movepixels mnt
+
+# ---------------------------------------------------------
 
 assemblage:	assemblage.c ${DEPS} 
-	gcc $(COPT) $< ../libfloatimg.a $(LIBS) -o $@
+	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 (wip)
+
+cachengn.o:	cachengn.c cachengn.h Makefile
+	gcc $(COPT) -c $< 
+
+tcache.o:	tcache.c cachengn.h Makefile
+	gcc $(COPT) -c $< 
+
+tcache:		tcache.o cachengn.o Makefile
+	gcc $(COPT) tcache.o cachengn.o $(LIBS) -o $@
 
-extracteur:	extracteur.c ${DEPS}
-	gcc $(COPT) $<  ../libfloatimg.a $(LIBS) -o $@

experiment/README.md

@@ -1,6 +1,29 @@
-# EXPÉRIMENTATION ÀLC
+# Expérimentations ÀLC
 
-## ASSEMBLAGE
+Attention, tout ce qui se trouve dans ce répertoire ne sont que des
+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.
 
-## EXTRACTEUR
+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

@@ -4,6 +4,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 
 #include  "../floatimg.h"
 
@@ -50,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

@@ -0,0 +1,145 @@
+/*
+ *		the chache engine - code
+ */
+
+#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("\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 wtfparam)
+{
+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

@@ -0,0 +1,29 @@
+/*
+ *		the chache engine - header
+ */
+
+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,131 +0,0 @@
-/*
- *		another ugly experiment
- */
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <unistd.h>
-
-#include  "../floatimg.h"
-
-// #include  "incrustator.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(__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
-
-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

@@ -0,0 +1,156 @@
+/*
+ *		MOVEPIXELS
+ *
+ *	This is experimental, do not use in production !
+ *
+ */
+
+#include   <stdio.h>
+#include   <stdlib.h>
+#include   <stdint.h>
+
+#include   <floatimg.h>
+
+int		verbosity;
+
+/* ------------------------------------------------------------------- */
+int displace(FloatImg *psrc, FloatImg *pshift, FloatImg *pdst, float k)
+{
+int		xd, yd, xs, ys;
+float		rgb[3], disp[3], maxv;
+float		minmax[6];
+int		foo, inside, outside;
+float		dltr, dltg, dltb;	/* delta des minmax */
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %p %g )\n", __func__,
+			psrc, pshift, pdst, k);
+#endif
+
+if (FIMG_TYPE_RGB != psrc->type) {
+	fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
+	return -7;
+	}
+if (fimg_images_not_compatible(psrc, pshift)) {
+	fprintf(stderr, "%s: bad shift image %d\n", __func__, pshift->type);
+	return -8;
+	}
+if (fimg_images_not_compatible(psrc, pdst)) {
+	fprintf(stderr, "%s: bad dst image %d\n", __func__, pdst->type);
+	return -8;
+	}
+
+foo = fimg_get_minmax_rgb(pshift, minmax);
+if (verbosity) {
+	fimg_print_minmax(minmax, (char *)__func__);
+	}
+dltr = minmax[1] - minmax[0];
+dltg = minmax[3] - minmax[2];
+dltb = minmax[5] - minmax[4];
+if (verbosity) fprintf(stderr, "delta shift  %f %f %f\n", dltr, dltg, dltb);
+
+maxv = fimg_get_maxvalue(psrc);
+inside = outside = 0;
+
+/* hardcoded parameters. this is very dirty :) */
+
+#define  MULT  (140.0)
+#define  OFFS  (70.0)
+
+/* loop over all the pixels of the DESTINATION picture */
+for (yd=0; yd<pdst->height; yd++) {
+
+	for (xd=0; xd<pdst->width; xd++) {
+
+		fimg_get_rgb(pshift, xd, yd, disp);
+
+		xs = xd + ((disp[0]/dltr*MULT) - OFFS);
+		ys = yd + ((disp[1]/dltb*MULT) - OFFS);
+
+		if ( xs<0 || xs>psrc->width 	||
+		     ys<0 || ys>psrc->height ) {
+			rgb[0] = rgb[1] = rgb[2] = 0.0;
+			outside++;
+			}
+		else {
+			fimg_get_rgb(psrc, xs, ys, rgb);
+			inside++;
+			}
+
+		fimg_put_rgb(pdst, xd, yd, rgb);
+		}
+
+	}
+
+// fprintf(stderr, "%s: inside %d outside %d\n", __func__, inside, outside);
+
+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;
+FloatImg	src, shift, dst;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %s %s 0x%04x )\n", __func__,
+				infile, outfile, k);
+#endif
+
+/* 'infile' contains the shifting values */
+foo = fimg_create_from_dump(infile, &shift);
+if (foo) {
+	fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
+	return foo;
+	}
+
+fimg_clone(&shift, &dst, 0);
+
+foo = fimg_create_from_dump(statfile, &src);
+if (foo) {
+	fprintf(stderr, "%s: error loading 'cumul.fimg'\n", __func__);
+	return foo;
+	}
+
+foo = displace(&src, &shift, &dst, 42.42);
+if (foo) {
+	fprintf(stderr, "%s: err %d in disp map 0\n", __func__, foo);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outfile, 0);
+if (foo) {
+	fprintf(stderr, "%s: err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
+return 0;
+}
+/* ------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+int		foo;
+char		*srcfile, *dstfile;
+
+if (3 != argc) {
+	fprintf(stderr, "usage:\n\t%s src.fimg dst.fimg\n", argv[0]);
+	exit(1);
+	}
+
+srcfile = argv[1];
+dstfile = argv[2];
+verbosity = 0;
+
+/* 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);
+
+return 0;
+}
+/* ------------------------------------------------------------------- */

experiment/muxplanes.c

@@ -0,0 +1,113 @@
+/*
+ *		another ugly experiment (please explain)
+ */
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+#include  <stdint.h>
+#include  <string.h>
+
+#include  "../floatimg.h"
+
+int		verbosity;
+
+/* --------------------------------------------------------------- */
+
+int triplane_muxer(FloatImg *sr, FloatImg *sg, FloatImg *sb,
+					FloatImg *dst)
+{
+int		sz;
+
+if (FIMG_TYPE_RGB != dst->type) {
+	fprintf(stderr, "%s: dst picz must be RGB, was %d\n",
+					__func__, dst->type);
+	return -99;
+	}
+
+if ( fimg_images_not_compatible(sr, sg) ||
+     fimg_images_not_compatible(sr, sb) ||
+     fimg_images_not_compatible(sr, dst) ) {
+	fprintf(stderr, "%s: compatibility error\n", __func__);
+	return -2;
+	}
+
+sz = sr->width * sr->height * sizeof(float);
+
+memcpy(dst->R, sr->R, sz);
+memcpy(dst->G, sg->G, sz);
+memcpy(dst->B, sb->B, sz);
+
+return 0;
+}
+/* --------------------------------------------------------------- */
+int try_this_muxplane(char *fr, char *fg, char *fb, char *dst, int flags)
+{
+int		foo;
+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);
+	return -1;
+	}
+foo = fimg_create_from_dump(fg, &img);
+if (foo) {
+	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, fb);
+	return -1;
+	}
+
+fimg_clone(&imr, &dest, 0);
+
+foo = triplane_muxer(&imr, &img, &imb, &dest);
+if (foo) {
+	fprintf(stderr, "%s: err %d\n", __func__, foo);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dest, dst, 0);
+if (foo) {
+	fprintf(stderr, "%s: err %d exporting to %s\n", __func__, foo, dst);
+	return foo;
+	}
+
+fimg_destroy(&imr);		fimg_destroy(&img);
+fimg_destroy(&imb);		fimg_destroy(&dest);
+
+return 0;
+}
+/* --------------------------------------------------------------- */
+int main(int argc, char *argv[])
+{
+int		foo;
+
+if (5 != argc) {
+	fprintf(stderr, "ERROR: %s need four fimg files arguments\n",
+				argv[0]);
+	return 1;
+	}
+
+/*
+ *	and now, we have to decipher options on the
+ *	command line.
+ */
+
+foo = try_this_muxplane(argv[1], argv[2], argv[3], argv[4], 0);
+if (foo) {
+	fprintf(stderr, "oups %d\n", foo);
+	exit(1);
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------- */

experiment/tcache.c

@@ -0,0 +1,49 @@
+/*
+ *		tests du systeme de cache
+ */
+
+#include  <stdio.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+#include  "cachengn.h"
+
+int		verbosity;
+
+#define IMGW	320
+#define IMGH	240
+
+#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, "\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);
+
+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;
+}
+/* ------------------------------------------------------------ */
+

experiment/tripla.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+GRABOPT=" -vv -d /dev/video0 -n 400 -p 0.5 -u "
+SPOOL=${HOME}/TMP
+
+echo ; echo ; echo
+
+for capture in red green blue
+do
+	image=${SPOOL}/${capture}.fimg
+	echo grabbing $image
+	grabvidseq ${GRABOPT} -o $image
+	echo
+done
+
+./muxplanes 	"${SPOOL}/red.fimg"			\
+		"${SPOOL}/green.fimg"			\
+		"${SPOOL}/blue.fimg"			\
+		yo.fimg
+
+echo $0 "got a" $?
+
+fimgstats -v yo.fimg
+

floatimg.h

@@ -1,37 +1,88 @@
 /*
  *			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	145
+#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 {
-	unsigned long	magic;
+	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;
 
 /*
- *	fimg file header
+ *	fimg file header (short version)
  */
 typedef struct {
-	char		magic[8];
+	char		magic[8];	/* this is not an asciiz ! */
-	int		w, h, t;
+	int32_t		w, h, t;
+	/*
+	 *  what about the packing ?
+	 */
 	} FimgFileHead;
 
+
 #define MAGIC_AREA51	0xA5EA0051
 typedef struct {
-	unsigned long	magic;
+	uint32_t	magic;
 	int		w, h;
 	int		x, y;
 	int		flags;
@@ -50,6 +101,8 @@ typedef struct {
 #define FILE_TYPE_FITS			6
 #define FILE_TYPE_BMP			7
 #define FILE_TYPE_EXR			8
+#define FILE_TYPE_DICOM			9
+#define FILE_TYPE_PGM			10
 
 /*	lib/contrast.c			*/
 #define CONTRAST_NONE			0
@@ -57,7 +110,7 @@ typedef struct {
 #define CONTRAST_POW2			2
 #define CONTRAST_COS01			3
 #define CONTRAST_COS010			4
-
+#define CONTRAST_XPER			5		/* use with caution */
 /*
  *	core module
  */
@@ -96,21 +149,26 @@ int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
 
 
+/* ---------------------------------------------------- */
 /*	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);
@@ -124,17 +182,33 @@ int fimg_highlight_color(FloatImg *src, FloatImg *dst,
 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);
+int fimg_decomp_rgbz_color(FloatImg *psrc, FloatImg *pdst, int k);
+int fimg_decomp_rgbz_gray(FloatImg *psrc, FloatImg *pdst, int k);
+
+int fimg_save_plane_as_dicom(FloatImg *src, char *outname,
+						char plane, int flags);
 
 /* universal exporter XXX */
 int fimg_export_picture(FloatImg *pic, char *fname, int flags);
 
 /*	PNM files module		*/
 int fimg_save_as_pnm(FloatImg *head, char *fname, int flags);
+int fimg_save_as_pgm(FloatImg *head, char *fname, int flags);
 int fimg_load_from_pnm(char *fname, FloatImg *head, int notused);
+int fimg_save_plane_as_pgm(FloatImg *psrc, char *fname, char plane);
 
 double fimg_timer_set(int whot);
 double fimg_timer_get(int whot);
@@ -151,16 +225,30 @@ 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);
 
+/*	--> funcs/pixelize.c
+			voir fimg_pixelize_h_rnd() */
+int fimg_pixelize_h_0(FloatImg *psrc, FloatImg *pdst, int k);
+int fimg_pixelize_h_rnd(FloatImg *psrc, FloatImg *pdst, int largeur);
+
 /* * * * experimental ! */
 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);
@@ -172,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);
 
@@ -181,13 +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 files module		*/
+/*	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 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);
@@ -196,19 +294,23 @@ 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);
 int   fimg_get_minmax_rgb(FloatImg *head, float mmvals[6]);
 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);
@@ -218,17 +320,22 @@ int   fimg_save_as_bmp(FloatImg *src, char *outname, int flags);
 
 int   fimg_test_pattern(FloatImg *fimg, int type, double dval);
 int   fimg_draw_something(FloatImg *fimg);
+int   fimg_mircol_1(FloatImg *dst, float mval);
 int   fimg_multirandom(FloatImg *fimg, long nbpass);
 
 /*	file is 'funcs/utils.c'		*/
 void fimg_print_minmax(float minmax[6], char *titre);
+float *charplane2int(char plane, FloatImg *img);
+
 int parse_WxH(char *str, int *pw, int *ph);
 int parse_double(char *str, double *dptr);
+int irand2(int offset, int modulo);
 int print_rectangle(char *str, FimgArea51 *rect);
 int parse_rectangle(char *str, FimgArea51 *r, int notused);
 int format_from_extension(char *fname);
 char * extension_from_format(int fmt);
 
+int fimg_clear_rectangle(FloatImg *pimg, int rect[4]);
 
 
 

funcs/.gitignore

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

funcs/Makefile

@@ -3,19 +3,27 @@
 #		Please, use the 'Gloabl.makefile' system !
 
 
-COPT = -Wall -fpic -g -no-pie  -DDEBUG_LEVEL=0
+COPT = -Wall -Wextra -fpic -g -no-pie  -DDEBUG_LEVEL=0
 DEPS = ../floatimg.h Makefile
 
 OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o	\
-	fimg-libpnm.o rampes.o sfx0.o sfx1.o sfx2.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						\
 	hsv.o classif.o contour2x2.o qsortrgb.o exporter.o	\
 	displacement.o dithering.o plasmas.o incrustator.o	\
-	recurse.o
+	killrgb.o recurse.o pixelize.o decomprgb.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						\
@@ -25,8 +33,9 @@ t:	t.c $(DEPS) ../libfloatimg.a tests.o
 		-ltiff						\
 		-lz -lm -o $@
 
-tests.o:	tests.c tests.h $(DEPS)
+tpnm:		tpnm.c Makefile fimg-libpnm.o
-	gcc $(COPT) -I/usr/include/netpbm -c $<
+	gcc $(COPT) -I/usr/include/netpbm 			\
+		fimg-libpnm.o -lnetpbm  $< -o $@
 
 #---------------------------------------------------------------
 #	upper-level functions
@@ -36,6 +45,18 @@ tests.o:	tests.c tests.h $(DEPS)
 
 # ###
 
+rectangle.o:		rectangle.c  $(DEPS)
+	gcc $(COPT) -c $<
+
+decomprgb.o:		decomprgb.c  $(DEPS)
+	gcc $(COPT) -c $<
+
+pixelize.o:		pixelize.c  $(DEPS)
+	gcc $(COPT) -c $<
+
+killrgb.o:		killrgb.c  $(DEPS)
+	gcc $(COPT) -c $<
+
 recurse.o:		recurse.c  $(DEPS)
 	gcc $(COPT) -c $<
 
@@ -45,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 $<
 
@@ -57,6 +81,9 @@ fimg-tiff.o:		fimg-tiff.c $(DEPS)
 fimg-openexr.o:		fimg-openexr.c $(DEPS)
 	gcc $(COPT) -c $<
 
+fimg-dicom.o:		fimg-dicom.c $(DEPS)
+	gcc $(COPT) -c $<
+
 fimg-fits.o:		fimg-fits.c $(DEPS)
 	gcc $(COPT) -I/usr/include/cfitsio/ -c $<
 
@@ -99,6 +126,12 @@ sfx1.o:			sfx1.c $(DEPS)
 sfx2.o:			sfx2.c $(DEPS)
 	gcc $(COPT) -c $<
 
+sfx3.o:			sfx3.c $(DEPS)
+	gcc $(COPT) -c $<
+
+sfx4.o:			sfx4.c $(DEPS)
+	gcc $(COPT) -c $<
+
 contour2x2.o:		contour2x2.c $(DEPS)
 	gcc $(COPT) -c $<
 
@@ -114,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,25 +2,52 @@
 
 Plein de fonctions qu'il serait bon de documenter :)
 
-## PNG
-
-__Attention__ : la bibliothèque `pnglite`actuellement utiilsée pour lire les
-fichiers PNG n'accepte que **certains** types de fichiers.
-Et en particulier, elle brotche sur ceux produits par ImageMagick !
 
 ## 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)
+`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.
+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
+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

@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include  <stdint.h>
 #include   <math.h>
 
 #include "../floatimg.h"
@@ -14,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;
@@ -25,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/contour2x2.c

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 #include   <math.h>
 

funcs/decomprgb.c

@@ -0,0 +1,157 @@
+/*
+ *	DECOMPOSITION RGB
+ */
+
+#include  <stdio.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+
+extern int		verbosity;
+
+/* == ---------------------------------------------------- == */
+
+/*	some dirty macros				*/
+
+#define pixidx(fi,x,y) (((y)*fi->width)+(x))
+
+#define getRpix(fi,x,y) (fi->R[ pixidx(fi,(x),(y)) ])
+#define getGpix(fi,x,y) (fi->G[ pixidx(fi,(x),(y)) ])
+#define getBpix(fi,x,y) (fi->B[ pixidx(fi,(x),(y)) ])
+
+/*	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)
+{
+int		x, y, x2, y2;
+int		w2, h2;
+float		cumul, vgray;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
+			psrc,  pdst, k);
+#endif
+
+/*
+ *	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++)
+	{
+	y2 = y * 2;
+	for (x=0; x<w2; x++) {
+		x2 = x * 2;
+
+		cumul = getRpix(psrc, x2, y2) +
+			getRpix(psrc, x2, y2+1) +
+			getRpix(psrc, x2+1, y2) +
+			getRpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray = cumul;
+		pdst->R[pixidx(pdst,x,y)] = cumul;
+		pdst->R[pixidx(pdst,x+w2,y+h2)] = cumul;
+
+		cumul = getGpix(psrc, x2, y2) +
+			getGpix(psrc, x2, y2+1) +
+			getGpix(psrc, x2+1, y2) +
+			getGpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray += cumul;
+		pdst->G[pixidx(pdst,x+w2,y)] = cumul;
+		pdst->G[pixidx(pdst,x+w2,y+h2)] = cumul;
+
+		cumul = getBpix(psrc, x2, y2) +
+			getBpix(psrc, x2, y2+1) +
+			getBpix(psrc, x2+1, y2) +
+			getBpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray += cumul;
+		pdst->B[pixidx(pdst,x,y+h2)] = cumul;
+		pdst->B[pixidx(pdst,x+w2,y+h2)] = cumul;
+
+		}
+
+	}
+
+
+return 0;
+}
+
+/* == ---------------------------------------------------- == */
+
+		/* PUTAIN LE COPIER/COLLÉ DE BATARD !!! */
+
+int fimg_decomp_rgbz_gray(FloatImg *psrc, FloatImg *pdst, int k)
+{
+int		x, y, x2, y2;
+int		w2, h2, idx;
+float		cumul, vgray;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
+			psrc,  pdst, k);
+#endif
+
+/*
+ *	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++)
+	{
+	y2 = y * 2;
+	for (x=0; x<w2; x++) {
+		x2 = x * 2;
+
+		cumul = getRpix(psrc, x2, y2) +
+			getRpix(psrc, x2, y2+1) +
+			getRpix(psrc, x2+1, y2) +
+			getRpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray = cumul;
+		idx = pixidx(pdst,x,y);
+		pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
+
+		cumul = getGpix(psrc, x2, y2) +
+			getGpix(psrc, x2, y2+1) +
+			getGpix(psrc, x2+1, y2) +
+			getGpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray += cumul;
+		idx = pixidx(pdst,x+w2,y);
+		pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
+
+		cumul = getBpix(psrc, x2, y2) +
+			getBpix(psrc, x2, y2+1) +
+			getBpix(psrc, x2+1, y2) +
+			getBpix(psrc, x2+1, y2+1);
+		cumul /= 4, vgray += cumul;
+		idx = pixidx(pdst,x,y+h2);
+		pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
+
+		idx = pixidx(pdst,x+w2,y+h2);
+		pdst->R[idx] = pdst->G[idx] = 		\
+				pdst->B[idx] =  vgray / 3.0;
+		}
+
+	}
+
+
+return 0;
+}
+
+/* == ---------------------------------------------------- == */

funcs/displacement.c

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 #include   <math.h>
 
@@ -21,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;
 
@@ -39,10 +39,14 @@ if (fimg_images_not_compatible(psrc, pdst)) {
 	}
 
 foo = fimg_get_minmax_rgb(psrc, minmax);
+if (foo) {
+	fprintf(stderr, "%s : err %d on get minmax\n", __func__, foo);
+	return 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];
 
@@ -59,7 +63,7 @@ for (y=0; y<psrc->height; y++) {
 		fimg_get_rgb(psrc, x, y, rgb);
 
 		dispx = (float)x + (rgb[1]/dltg * 20.0);
-		dispy = (float)y + (rgb[2]/dltb * 10.0);
+		dispy = (float)y + (rgb[2]/dltb * 20.0);
 		dstx = (int)roundf(dispx - 10.0);
 		dsty = (int)roundf(dispy - 10.0);
 
@@ -78,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

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 #include   <math.h>
 
@@ -16,11 +17,23 @@ 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++)
 		{
 
+		/* PLEASE DO SOMETHING HERE */
 
 		}
 	}

funcs/equalize.c

@@ -6,12 +6,55 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
 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];
@@ -30,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];
@@ -43,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

@@ -4,6 +4,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 
 #include "../floatimg.h"
@@ -24,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);
@@ -53,9 +56,15 @@ switch(filetype) {
 	case FILE_TYPE_BMP:
 		fprintf(stderr, "%s: file type BMP not implemented\n", __func__);
 		foo = -666;
+		break;
 	case FILE_TYPE_EXR:
 		fprintf(stderr, "%s: file type EXR experimental\n", __func__);
 		foo = fimg_save_as_exr(pic, fname, 0);
+		break;
+	case FILE_TYPE_PGM:
+		fprintf(stderr, "XXX %s EXPERIMENT!\n", __func__);
+		foo = fimg_save_as_pgm(pic, fname, 0);
+		break;
 	default:
 		foo = -1789;
 		break;

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

@@ -1,11 +1,43 @@
+/*
+ *		Floating filters are all WIP !
+ */
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 #include  <fcntl.h>
 #include  <float.h>
 
 #include  "../floatimg.h"
 
+extern int		verbosity;
+
+/* -------------------------------------------------------------------- */
+int fimg_show_filter(char *title, FimgFilter3x3 *filtr)
+{
+float		*M;			/* alias of filter matrix */
+int		idx;
+float		sum, value;
+
+if (title)	fprintf(stderr, "--------- %s ---------\n", title);
+
+M = filtr->matrix;			/* aliasing here */
+
+fprintf(stderr, "%8.3f   %8.3f   %8.3f\n", M[0], M[1], M[2]);
+fprintf(stderr, "%8.3f   %8.3f   %8.3f\n", M[3], M[4], M[5]);
+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);
+
+value = (sum * filtr->mult) + filtr->offset;
+fprintf(stderr, "      value:  %8.3f\n", value);
+
+return 0;
+}
 /* -------------------------------------------------------------------- */
 int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
 {
@@ -27,19 +59,21 @@ 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((char *)__func__, filtr);
+	}
+
 /*	aliasing some vars for cleaner code */
 pr = src->R;	pg = src->G;	pb = src->B;
 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)]	+
@@ -106,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]	+
@@ -123,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;
-
 	}
 }
 
@@ -164,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;
@@ -186,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);
@@ -197,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

@@ -0,0 +1,33 @@
+/*
+      Digital Imaging and Communications in Medicine
+
+ nouveau Fri 26 Nov 2021 11:12:44 PM CET - allée de Dinan
+
+ */
+
+#include  <stdio.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+
+extern int verbosity;		/* must be declared around main() */
+
+/* --------------------------------------------------------------------- */
+int fimg_save_plane_as_dicom(FloatImg *src, char *outname,
+						char plane, int flags)
+{
+float		*planeptr;
+
+fprintf(stderr, ">>> %s ( %p %s %c %d )\n", __func__, src, outname, plane, flags);
+
+planeptr = charplane2int(plane, src);		/* please explain XXX */
+fprintf(stderr, "planeptr is %p\n", planeptr);
+
+if (verbosity) {
+	fimg_describe(src, outname);
+	}
+
+return -1;
+}
+/* --------------------------------------------------------------------- */

funcs/fimg-fits.c

@@ -8,6 +8,8 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  <fitsio.h>
 
@@ -30,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) {
@@ -50,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

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 
 #include  <pam.h>        
@@ -13,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("\tformat              %d 0x%04x\n", ppam->format, ppam->format);
-
+printf("\tplainformat         %d\n",	ppam->plainformat);
-printf("    format              %d\n", ppam->format);
+printf("\twidth & height      %d %d\n", ppam->width, ppam->height);
-printf("    plainformat         %d\n", ppam->plainformat);
+printf("\tdepth               %d\n", ppam->depth);
-printf("    width & height      %d %d\n", ppam->width, ppam->height);
+printf("\tmaxval              %lu\n", ppam->maxval);
-printf("    depth               %d\n", ppam->depth);
-printf("    maxval              %lu\n", ppam->maxval);
-
 }
 /* --------------------------------------------------------------------- */
 
@@ -36,13 +36,14 @@ FILE			*fp;
 fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
 #endif
 
+printf("    --- infos for '%s' ------------\n", fname);
+
 if (NULL==(fp=fopen(fname, "r"))) {
 	perror(fname);
 	exit(1);
 	}
 
 pnm_readpaminit(fp, &inpam, sizeof(inpam));
-
 print_struct_pam(&inpam, fname);
 
 fclose(fp);

funcs/fimg-openexr.c

@@ -5,6 +5,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 
 #include "../floatimg.h"

funcs/fimg-png.c

@@ -5,6 +5,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include   <stdint.h>
 #include <string.h>
 
 #include <pnglite.h>        
@@ -86,7 +87,7 @@ if (PNG_NO_ERROR != foo) {
 	}
 
 ptr = datas;
-for (idx=0; idx<png.width * png.height; idx++) {
+for (idx=0; idx<(int)(png.width*png.height); idx++) {
 	fimg->R[idx] = (float)*ptr++;
 	fimg->G[idx] = (float)*ptr++;
 	fimg->B[idx] = (float)*ptr++;
@@ -131,7 +132,7 @@ if ( 3 != png.bpp ) {			/* TO BE PATCHED */
 	}
 
 /* check if floatimg and PNG have the same size */
-if ((fimg->width != png.width) || (fimg->height != png.height)) {
+if ((fimg->width != (int)png.width) || (fimg->height != (int)png.height)) {
 	fprintf(stderr, "%s : fatal error on images sizes\n", __func__);
 	exit(1);
 	}
@@ -150,7 +151,7 @@ if (PNG_NO_ERROR != foo) {
 	}
 
 ptr = datas;
-for (idx=0; idx<png.width * png.height; idx++) {
+for (idx=0; idx<(int)(png.width*png.height); idx++) {
 	fimg->R[idx] = (float)*ptr++;
 	fimg->G[idx] = (float)*ptr++;
 	fimg->B[idx] = (float)*ptr++;
@@ -170,9 +171,13 @@ 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) {
+	fprintf(stderr, "*** in %s, flags are %08x\n", __func__, flags);
+	}
+
 /* convert ou floating datas to a byte/rgb array */
    /* first, alloc a buffer */
 sz = src->width * src->height;

funcs/fimg-tiff.c

@@ -5,7 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-
+#include  <stdint.h>
 #include  <tiffio.h>
 
 #include  "../floatimg.h"
@@ -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) {
@@ -44,6 +47,8 @@ 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

@@ -5,6 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 
 #include  "../floatimg.h"
@@ -26,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);
@@ -64,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");
@@ -105,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;
@@ -131,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;
 }
@@ -148,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/histogram.c

@@ -6,6 +6,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <string.h>
+#include  <stdint.h>
 
 #include  "../floatimg.h"
 

funcs/hsv.c

@@ -10,12 +10,19 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <string.h>
 #include  <math.h>
 #include  "../floatimg.h"
 
 extern int		verbosity;
 
+/*
+     https://baillehachepascal.dev/2021/rgb_hsv.php
+
+
+
+*/
 /* --------------------------------------------------------------------- */
 /*	helper functions						 */
 static float maxi3f(float a, float b, float c)
@@ -28,7 +35,7 @@ return ((a < b)? (a < c ? a : c) : (b < c ? b : c));
 }
 static int pseudoeq(float a, float b)
 {
-return (fabsf(a-b)<0.00000000000001);		// UGLY HACK ???
+return (fabsf(a-b)<0.00000001);			// UGLY HACK ???
 }
 /* --------------------------------------------------------------------- */
 /*
@@ -78,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;
 	}
 
@@ -124,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

@@ -5,6 +5,7 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
 #include  <stdlib.h>
 
 #include  "../floatimg.h"
@@ -19,9 +20,12 @@ static int check_boundaries(FloatImg *from, FloatImg *to, FimgArea51 *a51)
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, from, to, a51);
+#endif
+
+if (verbosity > 1) {
 	fimg_printdims("from", from);
 	fimg_printdims("to  ", to);
-#endif
+	}
 
 /* just a small molly-guard */
 if ( (a51->w < 0) || (a51->h < 0) ) {
@@ -29,13 +33,13 @@ if ( (a51->w < 0) || (a51->h < 0) ) {
 	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);
@@ -43,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)
 {
@@ -57,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");
@@ -66,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

@@ -0,0 +1,45 @@
+/*
+ *		KILL RGB !
+ *
+ *	nouveau TerreBlanque 4 octobre 2021
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <stdint.h>
+#include  <math.h>
+
+#include  "../floatimg.h"
+#include  "tests.h"
+
+/* --------------------------------------------------------------------- */
+
+int fimg_killrgb_v(FloatImg *src, FloatImg *dst, int k)
+{
+int		line, col;
+int		ir;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p  %p  %d )\n", __func__, src, dst, k);
+#endif
+
+if (k) { fprintf(stderr, "in %s k was %d\n", __func__, k); }
+
+fimg_clear(dst);
+ir = 0;
+
+for (line=0; line<src->height; line++) {
+	// fprintf(stderr, "%s line %d\n", __func__, line);
+	for (col=0; col<(src->width-3); col+=3) {
+
+		dst->R[ir  ] = src->R[ir];	ir++; 
+		dst->G[ir+1] = src->G[ir];	ir++; 
+		dst->B[ir+2] = src->B[ir];	ir++; 
+
+		}
+	}
+
+return 0;
+}
+
+/* --------------------------------------------------------------------- */

funcs/misc-plots.c

@@ -4,11 +4,17 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <math.h>
 
 #include  "../floatimg.h"
 
 /* --------------------------------------------------------------------- */
+/*
+ *********************************************
+ *       SEGFAULT SI IMAGE TROP PETITE       *
+ *********************************************
+*/
 
 int fimg_test_pattern(FloatImg *fimg, int type, double dval)
 {
@@ -25,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++) {
@@ -45,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++) {
@@ -55,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;
 }
 /* --------------------------------------------------------------------- */
@@ -86,6 +119,24 @@ for (y=1; y<fimg->height; y++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+int fimg_mircol_1(FloatImg *dst, float mval)
+{
+int		x, y;
+float		fx, fy, rgb[3];
+
+for (y=0; y<dst->height; y++) {
+	fy = (float)y / (float)dst->height;
+	for (x=0; x<dst->width; x++) {
+		fx = (float)x / (float)dst->width;
+		rgb[0] = mval * fx;
+		rgb[1] = mval * ((fx+fy)/2.0);
+		rgb[2] = mval * fy;
+		fimg_put_rgb(dst, x, y, rgb);
+		}
+	}
+return -1;
+}
+/* --------------------------------------------------------------------- */
 int fimg_multirandom(FloatImg *fimg, long nbpass)
 {
 int	foo, x, y;

funcs/pixelize.c

@@ -0,0 +1,101 @@
+/*
+ *		P I X E L I Z E
+ */
+#include  <stdio.h>
+#include  <stdint.h>
+#include  <stdlib.h>
+
+#include  "../floatimg.h"
+
+extern int		verbosity;
+
+/*   --------------------------------------------------------------   */
+/* nouveau 10 octobre 2021 dans la roulotte de Terreblanque */
+
+#define LARGEUR  16
+
+int fimg_pixelize_h_0(FloatImg *psrc, FloatImg *pdst, int largeur)
+{
+int		line, col, loop, idx;
+float		cr, cg, cb;		/* cumuls */
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, largeur);
+#endif
+
+if (fimg_images_not_compatible(psrc, pdst)) {
+	fprintf(stderr, "%s: err compatibility\n", __func__);
+	return -8;
+	}
+
+switch(largeur) {
+	case 8:	 case 16: case 32:
+		break;
+	default:
+		fprintf(stderr, "%s: bad width %d\n", __func__, largeur);
+		return -77;
+	}
+
+for (line=0; line<psrc->height; line++) {
+	for (col=0; col<psrc->width; col+=largeur) {
+		cr = cg = cb = 0.0;
+		idx = line * psrc->width + col;
+		for (loop=0; loop<largeur; loop++) {
+			cr += psrc->R[idx+loop];
+			cg += psrc->G[idx+loop];
+			cb += psrc->B[idx+loop];
+			}
+		for (loop=0; loop<largeur; loop++) {
+			pdst->R[idx+loop] = cr / (float)largeur;
+			pdst->G[idx+loop] = cg / (float)largeur;
+			pdst->B[idx+loop] = cb / (float)largeur;
+			}
+		}
+	}
+
+return 0;
+}
+/*   --------------------------------------------------------------   */
+/*
+ *	un essai dans la roulotte :)
+ *	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)
+{
+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);
+		flag = ! flag;
+		}
+	else	{
+		count = irand2(20, 40);
+		flag = ! flag;
+		}
+	if (verbosity) {
+		fprintf(stderr, "%s c=%d f=%c\n", __func__,
+					count, flag?'T':'F');
+		}
+	}
+
+if (verbosity) {
+	fprintf(stderr, "%s: count=%d flag=%d\n", __func__, count, flag);
+	}
+
+foo = fimg_pixelize_h_0(psrc, pdst, flag ? largeur : 32);
+if (foo) {
+	fprintf(stderr, "pixelize_h_0 give err %d  in %s\n", foo, __func__);
+	}
+
+count--;		/* nice trick bro */
+
+return 0;
+}
+/*   --------------------------------------------------------------   */

funcs/plasmas.c

@@ -7,6 +7,8 @@
 
 #include  <stdio.h>
 #include  <math.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include "../floatimg.h"
 
@@ -29,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[0] = sin(dx*10 + time + dy) + 1.0;
-		rgb[1] = sin(dx*12 + time) + 1.0;
+		rgb[1] = sin(dx*12 + time + dy) + 1.0;
-		rgb[2] = sin(dx*14 + time) + 1.0;
+		rgb[2] = sin(dx*14 + time + dy) + 1.0;
 		fimg_put_rgb(img, x, y, rgb);
-
 		}
-
 	}
 
 return 0;

funcs/qsortrgb.c

@@ -4,6 +4,7 @@
 
 #include   <stdio.h>
 #include   <stdlib.h>
+#include   <stdint.h>
 #include   <string.h>
 #include   <math.h>
 
@@ -27,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;
@@ -77,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

@@ -4,6 +4,9 @@
  */
 
 #include  <stdio.h>
+#include  <stdint.h>
+#include  <stdlib.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
@@ -21,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++) {
@@ -49,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;
-	value *= dcoef;
 for (x=0; x<img->width; x++) {
+	value = (float)x / (float)img->width;
+	value *= dcoef;
+	for (y=0; y<img->height; y++) {
 		fimg_plot_rgb(img, x, y, value, value, value);
 		}
 	}
@@ -61,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/rectangle.c

@@ -0,0 +1,38 @@
+/*
+ *			R E C T A N G L E
+ *		This is an eternal WIP, sorry...
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <stdint.h>
+#include  <string.h>
+
+#include  <math.h>
+
+#include  "../floatimg.h"
+
+/* --------------------------------------------------------------------- */
+int fimg_clear_rectangle(FloatImg *pi, int coo[4])
+{
+int		line, off;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, pi, coo);
+#endif
+
+	/* please add boudary checks */
+
+for (line=0; line<coo[3]; line++) {
+	off = (line+coo[1])*pi->width + coo[0];
+	// fprintf(stderr, "line %3d   off %8d\n", line, off);
+	/* Kaboum ! */
+	memset(pi->R + off, 0, coo[2]*sizeof(float));
+	memset(pi->G + off, 0, coo[2]*sizeof(float));
+	memset(pi->B + off, 0, coo[2]*sizeof(float));
+	}
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+

funcs/recurse.c

@@ -5,6 +5,9 @@
 
 #include   <stdio.h>
 #include   <math.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+#include  <stdlib.h>
 
 #include   "../floatimg.h"
 
@@ -20,6 +23,23 @@ 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
+ */
+
 return -1;
 }
 /* -------------------------------------------------------------------- */

funcs/rotate.c

@@ -6,6 +6,8 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
@@ -23,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/saturation.c

@@ -3,6 +3,8 @@
  */
 
 #include  <stdio.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
@@ -99,7 +101,7 @@ coefs[0] = coefs[2] = coefs[4] = minima;
 
 foo = fimg_shift_to_zero(src, dst, coefs);
 if (foo) {
-	fprintf(stderr, "%s WTF?\n", __func__);
+	fprintf(stderr, "%s WTF? %d\n", __func__, foo);
 	return foo;
 	}
 

funcs/sfx0.c

@@ -5,6 +5,8 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
@@ -24,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];
@@ -34,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)
 {
@@ -48,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/sfx1.c

@@ -6,6 +6,8 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 

funcs/sfx2.c

@@ -5,6 +5,8 @@
 
 #include  <stdio.h>
 #include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
 
 #include  "../floatimg.h"
 
@@ -23,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;
@@ -52,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
@@ -91,4 +103,7 @@ for (foo=0; foo<size; foo++) {
 return 0;
 }
 /* -------------------------------------------------------------- */
-
+/*
+ *			ici, il manque le quaternize :)
+ */
+/* -------------------------------------------------------------- */

funcs/sfx3.c

@@ -0,0 +1,99 @@
+/*
+ *		FLOATIMG - a kluge from tTh
+ *		---------------------------
+ *
+ *	some strange effects on floating pictures, made in
+ *	the batcave of "Le Bib", in Montpellier.
+ */
+
+
+#include  <stdio.h>
+#include  <string.h>
+#include  <stdlib.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+
+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)
+{
+float		halfval;
+float		rgb[3];
+int		x, y, foo;
+
+#if DEBUG_LEVEL
+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: kval=%f & halfval=%f\n", __func__,
+				kval,	halfval);
+	}
+
+for (y=0; y<src->height; y++) {
+	for (x=0; x<src->width; x++) {
+		foo =  fimg_get_rgb(src, x, y, rgb);
+		if (foo)	return foo;
+
+		if (rgb[0] > halfval)		rgb[0] /= 2.0;
+		if (rgb[1] > halfval)		rgb[1] /= 2.0;
+		if (rgb[2] > halfval)		rgb[2] /= 2.0;
+
+		foo =  fimg_put_rgb(dst, x, y, rgb);
+		if (foo)	return foo;
+		}
+	}
+
+return 0;
+}
+/* -------------------------------------------------------------- */
+

funcs/sfx4.c

@@ -0,0 +1,120 @@
+/*
+ *		FLOATIMG - a kluge from tTh
+ *		---------------------------
+ *
+ *	some strange effects on floating pictures.
+ */
+
+
+#include  <stdio.h>
+#include  <string.h>
+#include  <stdint.h>
+#include  <sys/time.h>
+
+#include  "../floatimg.h"
+
+extern int		verbosity;
+
+/* -------------------------------------------------------------- */
+int fimg_sfx_triplemul(FloatImg *src, FloatImg *dst, int notused)
+{
+int		x, y, foo;
+float		in[3], out[3];
+
+#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__);
+	}
+
+for (y=0; y<src->height; y++) {
+	for (x=0; x<src->width; x++) {
+		foo =  fimg_get_rgb(src, x, y, in);
+		if (foo)	return foo;
+		out[0] = in[1] * in[2];
+		out[1] = in[0] * in[2];
+		out[2] = in[0] * in[1];
+		// fprintf(stderr, "%9f %9f %9f\n", out[0], out[1], out[2]);
+		foo =  fimg_put_rgb(dst, x, y, out);
+		if (foo)	return foo;
+		}
+	}
+
+return 0;
+}
+/* -------------------------------------------------------------- */
+/*
+ * see also:
+	sfx3.c:fimg_crump_hard()
+*/
+int fimg_split_level(FloatImg *src, FloatImg *dst, int notused)
+{
+float		means[4];
+// 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;
+	}
+
+surface = src->width*src->height;
+for(idx=0; idx<surface; idx++) {
+	if (src->R[idx]<means[0])   dst->R[idx]=src->R[idx]*2.0;
+	else     dst->R[idx]=(src->R[idx]-means[0])*2.0;
+	if (src->G[idx]<means[1])   dst->G[idx]=src->G[idx]*2.0;
+	else     dst->G[idx]=(src->G[idx]-means[1])*2.0;
+	if (src->B[idx]<means[2])   dst->B[idx]=src->B[idx]*2.0;
+	else     dst->B[idx]=(src->B[idx]-means[2])*2.0;
+	}
+
+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

@@ -5,6 +5,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 #include  <pam.h>
 
@@ -22,7 +23,10 @@ float		global_fvalue;
 enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
 			Histo, Hsv, Classif, Ctr2x2, Qsortrgb,
 			Displace, ReadPNG, Plasmas, Hilight, OpenEXR,
-			Geometrie, FileType, Mirror  };
+			Geometrie, FileType, Mirror, KillRGB,
+			Pixelize,SplitLevel, DecompRgbz, DecompRgbg,
+			Rectangle, Dicom, Fakolor0, Fakolor3,
+			Fmorpho0, Fluffy, ThermoCol, TriPtyq  };
 typedef struct {
 	char	*name;
 	int	Cmd;
@@ -50,6 +54,19 @@ Command commands[] = {
 	{ "geometrie",	Geometrie,	},
 	{ "filetype",	FileType	},
 	{ "mirror",	Mirror		},
+	{ "killrgb",	KillRGB		},
+	{ "pixelize",	Pixelize	},
+	{ "spltlvl",	SplitLevel	},
+	{ "decomprgbz",	DecompRgbz	},
+	{ "decomprgbg",	DecompRgbg	},
+	{ "rectangle",  Rectangle	},
+	{ "dicom",      Dicom		},
+	{ "fakolor0",	Fakolor0	},
+	{ "fakolor3",	Fakolor3	},
+	{ "fmorpho0",	Fmorpho0	},
+	{ "fluffy",	Fluffy		},
+	{ "thermocol",	ThermoCol	},
+	{ "triptyq",    TriPtyq		},
 	{ NULL,		0		}
 	} ;
 
@@ -87,15 +104,21 @@ 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");
 
+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);
+
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@@ -215,6 +238,45 @@ switch(opt) {
 	case Mirror:
 		foo = essai_miroir(filename, outfile, 0);
 		break;
+	case KillRGB:
+		foo = essai_killrgb(filename, outfile);
+		break;
+	case Pixelize:
+		foo = essai_pixelize(filename, outfile);
+		break;
+	case SplitLevel:
+		foo = essai_split_level(filename, outfile, 0);
+		break;
+	case DecompRgbz:
+		foo = essai_decomprgb_color(filename, outfile);
+		break;
+	case DecompRgbg:
+		foo = essai_decomprgb_gray(filename, outfile);
+		break;
+	case Rectangle:
+		essai_rectangle(outfile, 0);
+		break;
+	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);
 		exit(1);
@@ -222,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,10 +1,14 @@
 /*
+ *			FLOATIMG
+ *			--------
+
  *	tests des fonctions diverses - subroutines
 	see also: t.c
  */
 
 #include <stdio.h>
 #include <stdlib.h>
+#include  <stdint.h>
 #include <string.h>
 #include  <pam.h>
 
@@ -16,6 +20,267 @@
 
 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)
+{
+int		foo;
+FloatImg	img;
+
+fprintf(stderr, ">>> %s ( %s %s %d )\n", __func__, inf, outf, k);
+
+foo = fimg_create(&img, 320, 240, FIMG_TYPE_RGB);
+fimg_drand48(&img, 1.0);
+
+foo = fimg_save_plane_as_dicom(&img, outf, 'R', 0);
+fprintf(stderr, "dicom: save a plane --> %d\n", foo);
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+int essai_rectangle(char *outf, int k)
+{
+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);
+
+rect[0] = 100;		rect[1] = 100;
+rect[2] = 32;		rect[3] = 16;
+
+foo = fimg_clear_rectangle(&img, rect);
+
+foo = fimg_export_picture(&img, outf, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
+fimg_destroy(&img);
+return 0;
+}
+/* --------------------------------------------------------------------- */
+int essai_killrgb(char *inf, char *outf)
+{
+int		foo;
+FloatImg	src, dst;
+
+fprintf(stderr, ">>> %s ( %s %s )\n", __func__, inf, outf);
+
+foo = fimg_create_from_dump(inf, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		inf);
+	return foo;
+	}
+fimg_clone(&src, &dst, 1);
+
+foo = fimg_killrgb_v(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "%s:%s(): fail %d line %d\n",
+			__FILE__, __func__, foo, __LINE__);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outf, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+int essai_decomprgb_gray(char *inf, char *outf)
+{
+int		foo;
+FloatImg	src, dst;
+
+fprintf(stderr, ">>> %s ( %s %s )\n", __func__, inf, outf);
+
+foo = fimg_create_from_dump(inf, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		inf);
+	return foo;
+	}
+fimg_clone(&src, &dst, 1);
+
+foo = fimg_decomp_rgbz_gray(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "%s:%s(): fail %d line %d\n",
+			__FILE__, __func__, foo, __LINE__);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outf, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
+fimg_destroy(&src);   fimg_destroy(&dst);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+int essai_decomprgb_color(char *inf, char *outf)
+{
+int		foo;
+FloatImg	src, dst;
+
+fprintf(stderr, ">>> %s ( %s %s )\n", __func__, inf, outf);
+
+foo = fimg_create_from_dump(inf, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		inf);
+	return foo;
+	}
+fimg_clone(&src, &dst, 1);
+
+foo = fimg_decomp_rgbz_color(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "%s:%s(): fail %d line %d\n",
+			__FILE__, __func__, foo, __LINE__);
+	return foo;
+	}
+
+foo = fimg_export_picture(&dst, outf, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
+fimg_destroy(&src);   fimg_destroy(&dst);
+
+return 0;
+}
 /* --------------------------------------------------------------------- */
 
 int fimg_recursion_proto(FloatImg *src, FloatImg *dst, int notused);
@@ -72,7 +337,7 @@ fimg_clone(&src, &dst, 0);
 /*	run the crappy code */
 foo = fimg_mirror(&src, &dst, 0);
 if (foo) {
-	fprintf(stderr, "err %d in fimg_mirrot\n", foo);
+	fprintf(stderr, "err %d in fimg_mirror\n", foo);
 	return -6;
 	}
 
@@ -82,6 +347,72 @@ if (foo) {
 	return 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)
+{
+int		foo;
+FloatImg	src, dst;
+
+fprintf(stderr, ">>> %s ( '%s' '%s' 0x%X )\n", __func__,
+				inf, outf, flags);
+
+foo = fimg_create_from_dump(inf, &src);
+if (0 != foo) {
+	fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
+				foo, 		inf);
+	return foo;
+	}
+fimg_clone(&src, &dst, 0);
+foo = fimg_split_level(&src, &dst, 0);
+if (foo) {
+	fprintf(stderr, "err %d in split_level\n", foo);
+	return -6;
+	}
+foo = fimg_export_picture(&dst, outf, 0);
+if (foo) {
+	fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
+	return foo;
+	}
+
 return 0;
 }
 /* --------------------------------------------------------------------- */
@@ -571,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);
@@ -709,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;
@@ -827,4 +1166,77 @@ fprintf(stderr, "\\o/ end of %s\n", __func__);
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/*
+ *	dans la roulotte de terreblanque
+ */
+int essai_pixelize(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_pixelize_h_0(&src, &dst, 8);
+if (foo) {
+	fprintf(stderr, "in %s, pixelize give us a %d\n", __func__, foo);
+	return foo;
+	}
+
+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 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

@@ -5,6 +5,11 @@
 
 int essai_plasma(char *infile, char *outfile, int ikoef, float fkoef);
 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);
 int essai_qsort_rgb(char *infile, char *outfile);
@@ -24,9 +29,18 @@ 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);
+
+int essai_rectangle(char *outf, int k);
+
+int essai_dicom(char *inf, char *outf, int k);

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

@@ -3,7 +3,9 @@
  */
 
 #include  <stdio.h>
+#include  <stdlib.h>
 #include  <string.h>
+#include  <stdint.h>
 
 #include  "../floatimg.h"
 
@@ -19,6 +21,30 @@ fprintf(stderr, "green\t\t%10f   %10f\n", minmax[2], minmax[3]);
 fprintf(stderr, "blue\t\t%10f   %10f\n",  minmax[4], minmax[5]);
 }
 /* --------------------------------------------------------------------- */
+/* used in fimg-fits & fimg-dicom */
+float *charplane2int(char plane, FloatImg *img)
+{
+float		*pplane = NULL;
+
+fprintf(stderr, "get plane for '%c' in %p ", plane, img);
+
+switch (plane) {
+	case 'r':	case 'R':
+		pplane = img->R;		break;
+	case 'g':	case 'G':
+		pplane = img->G;		break;
+	case 'b':	case 'B':
+		pplane = img->B;		break;
+
+	default:
+		pplane = NULL;
+	}
+
+fprintf(stderr, "give me %p\n", pplane);
+
+return pplane;
+}
+/* --------------------------------------------------------------------- */
 int parse_WxH(char *str, int *pw, int *ph)
 {
 // char			*ptr;
@@ -52,6 +78,12 @@ if (1 == foo) {
 return -1;
 }
 /* --------------------------------------------------------------------- */
+/* new Mon 11 Oct 2021 08:28:27 PM CEST */
+int irand2(int offset, int modulo)
+{
+return offset + (rand() % modulo);
+}
+/* --------------------------------------------------------------------- */
 int file_type_from_name(char *name)
 {
 
@@ -67,6 +99,8 @@ if (!strcasecmp(name, "tiff"))	return FILE_TYPE_TIFF;
 if (!strcasecmp(name, "tif" ))		return FILE_TYPE_TIFF;
 if (!strcasecmp(name, "fits"))		return FILE_TYPE_FITS;
 if (!strcasecmp(name, "exr"))		return FILE_TYPE_EXR;
+if (!strcasecmp(name, "dicom"))		return FILE_TYPE_EXR;
+if (!strcasecmp(name, "pgm" ))		return FILE_TYPE_PGM;
 
 return -1;
 }
@@ -74,6 +108,12 @@ return -1;
 /* --------------------------------------------------------------------- */
 int print_rectangle(char *str, FimgArea51 *rect)
 {
+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;
@@ -86,17 +126,28 @@ int parse_rectangle(char *str, FimgArea51 *r, int notused)
 {
 int		x, y, w, h, foo;
 
-if (verbosity)
+#if DEBUG_LEVEL
-	fprintf(stderr, "parsing %s\n", str);
+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

@@ -2,11 +2,12 @@
 #	building the base library
 #
 
-COPT = -Wall -fpic -g   -no-pie -DDEBUG_LEVEL=0
+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
+	interpolate.o fimg-compare.o contrast.o		\
+	metadata.o alphachan.o
 
 DEPS = Makefile ../floatimg.h
 
@@ -23,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 $<
 
@@ -35,6 +39,9 @@ fimg-2gray.o:	fimg-2gray.c $(DEPS)
 operators.o:	operators.c $(DEPS)
 	gcc $(COPT) -c $<
 
+metadata.o:	metadata.c $(DEPS)
+	gcc $(COPT) -c $<
+
 contrast.o:	contrast.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

@@ -1,9 +1,14 @@
 /*
  *		contrast.c - part of libfloatimg
+ *		--------------------------------
+ *
+ *	you can see some use in 'tools/fimgfx.c', so you can thing
+ *	about the 'maxval' parameter. It was touchy :)
  */
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <unistd.h>
 #include  <string.h>
 #include  <math.h>
@@ -21,6 +26,11 @@ if (!strcmp(str, "sqrt")) 	return CONTRAST_SQRT;
 if (!strcmp(str, "pow2")) 	return CONTRAST_POW2;
 if (!strcmp(str, "cos01")) 	return CONTRAST_COS01;
 if (!strcmp(str, "cos010")) 	return CONTRAST_COS010;
+if (!strcmp(str, "xper")) 	return CONTRAST_XPER;
+
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: unknow contrast name '%s'\n", __func__, str);
+#endif
 
 return -1;
 }
@@ -48,7 +58,6 @@ else	{
 		}
 	}
 
-
 nbre = s->width * s->height;
 
 for (idx=0; idx<nbre; idx++) {
@@ -83,7 +92,6 @@ else	{
 		}
 	}
 
-
 nbre = s->width * s->height;
 
 for (idx=0; idx<nbre; idx++) {
@@ -97,7 +105,6 @@ for (idx=0; idx<nbre; idx++) {
 
 return 0;
 }
-
 /* ---------------------------------------------------------------- */
 /*
 		#macro Cos_01( X )
@@ -109,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,9 +1,12 @@
 /*
  *		fimg-2gray.c
+ *
+ *	This is a tricky job...
  */
 
 #include  <stdio.h>
 #include  <stdlib.h>
+#include  <stdint.h>
 #include  <unistd.h>
 #include  "string.h"
 
@@ -14,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 */
@@ -33,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) +
@@ -58,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;
@@ -65,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;