FloatImg sources upgraded to version 150

FloatImg sources upgraded to version 148
Add v4l tools to build system
2021-05-19 21:53:22 +02:00 · 2021-05-16 11:43:46 +02:00 · 2021-05-14 00:23:21 +02:00 · 2021-05-13 12:32:20 +02:00 · 2021-05-11 22:44:13 +02:00
179 changed files with 1134 additions and 6789 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,23 +1,18 @@
-lib/*.o
+build
 lib/t
 lib/*.fimg
 lib/*.png
 lib/*.gif
 # src/lib/*.o
 src/lib/t
 src/lib/*.fimg
 src/lib/*.png
 src/lib/*.gif
 *.o
 *.a
 gmon.out
 cscope.out
 *.swp
 *.pnm
 *.pgm
 *.fimg
 essai
 MANIFEST
 tarball
 */*.ps
 doc/*.toc
@ -30,32 +25,62 @@ doc/*.ind
 doc/co*.tex
 doc/foo.html
 src/funcs/t
 src/funcs/*.o
 src/funcs/*.png
 src/funcs/V/*
 src/src/funcs/*.gif
 src/funcs/*.fits
 src/funcs/*.tiff
 src/funcs/toto
 scripts/*.fimg
 scripts/*.pnm
 scripts/*.gif
-v4l2/t
+src/v4l2/t
-v4l2/capture
+src/v4l2/capture
-v4l2/grabvidseq
+src/v4l2/grabvidseq
-v4l2/*.o
+src/v4l2/*.o
-v4l2/*.ppm
+src/v4l2/*.ppm
-v4l2/*.png
+src/v4l2/*.png
-v4l2/*.fits
+src/v4l2/*.fits
-v4l2/*.tiff
+src/v4l2/*.tiff
-v4l2/video-infos
+src/v4l2/video-infos
-v4l2/nc-camcontrol
+src/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
 src/tools/*.png
 src/tools/*.tiff
-Fonderie/*.o
+extras/Fonderie/*.o
-Fonderie/*.png
+extras/Fonderie/*.png
-Fonderie/*.pnm
+extras/Fonderie/*.pnm
-Fonderie/*.gif
+extras/Fonderie/*.gif
-Fonderie/*.fimg
+extras/Fonderie/*.fimg
-Fonderie/fonderie
+extras/extras/Fonderie/fonderie
-Fonderie/interpolator
+extras/Fonderie/interpolator
-Fonderie/t
+extras/Fonderie/t
-Fonderie/singlepass
+extras/Fonderie/singlepass
-Fonderie/crapdef.h
+extras/Fonderie/crapdef.h
-Fonderie/crapstr.h
+extras/Fonderie/crapstr.h
 extras/experiment/assemblage
 extras/experiment/extracteur
 extras/experiment/*.fimg
 extras/experiment/*.pnm
 extras/experiment/*.o
--- a/Fonderie/craplist2str.awk
+++ b/Fonderie/craplist2str.awk
@ -1,28 +0,0 @@
 #!/usr/bin/awk -f
 #
 #		this utility script make a file who
 #		is includet by 'crapulator.c'
 #
 BEGIN	{
 	print "// -------------------------------------"
 	print "// generated file, do not edit by hand !";
 	print "// -------------------------------------"
 	print "Crapulor  CrapL[] = {";
 	}
 #		$1 is the badly brain-designed numeric id
 #		$2 is the user name of the filter
 #		$3 and $4 are two not used parameters
 #
 	{
 	name = sprintf("CR_%s", $2)
 	printf "   { %-14s,  \"%s\",       %d, %f },      // #%d\n",
                        name,    $2,   $3, $4,           $1;
 	}
 END	{
 	print "   { -1, NULL }"
 	print " };"
 	print "// ! generated file, do not edit by hand !"
 	}
--- a/Fonderie/utilfuncs.c
+++ b/Fonderie/utilfuncs.c
@ -1,53 +0,0 @@
 /*
 *		utilfuncs.c
 *
 * new Sat Nov  9 22:15:15 UTC 2024
 */
 #include  <stdio.h>
 #include  <unistd.h>
 #include  <sys/types.h>
 #include  <sys/stat.h>
 #include  "utilfuncs.h"
 extern int verbosity;
 /* -------------------------------------------------------------- */
 int check_if_export_dir_is_valid(char *path, int action)
 {
 int		foo;
 struct stat	statbuf;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( '%s', %d )\n", __func__, path, action);
 #endif
 foo = stat(path, &statbuf);
 if (foo) {
 	if (verbosity) perror(path);
 	return 0;
 	}
 #if DEBUG_LEVEL
 fprintf(stderr, "    mode 0x%x\n", statbuf.st_mode);
 #endif
 if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
 	if (verbosity) fprintf(stderr, "%s: Not a directory\n", path);
 	return 0;
 	}
 /* OK, c'est un repertoire, mais peut-on écrire dedans ? */
 foo = access(path, W_OK);
 #if DEBUG_LEVEL
 fprintf(stderr, "    access '%s' = %d\n", path, foo);
 #endif
 if (0 != foo) {
 	if (verbosity) fprintf(stderr, "%s: can't write\n", path);
 	return 0;
 	}
 return 1;		/* export dir is OK */
 }
 /* -------------------------------------------------------------- */
--- a/Fonderie/utilfuncs.h
+++ b/Fonderie/utilfuncs.h
@ -1,11 +0,0 @@
 /*
 *		utilfuncs.c
 *
 * new Sat Nov  9 22:15:49 UTC 2024
 */
 /* -------------------------------------------------------------- */
 int check_if_export_dir_is_valid(char *path, int action);
 /* -------------------------------------------------------------- */
--- a/Global.makefile
+++ b/Global.makefile
@ -1,6 +0,0 @@
 #
 #	This file is the 'grandmasta' of the compilation process.
 #			for now, this is juste a wip idea.
 #
--- a/14
+++ b/14
@ -1,14 +0,0 @@
            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.
--- a/94
+++ b/94
@ -1,37 +1,77 @@
-####################################################
+# CC_OPTS = -Wall -fpic -g -pg  -no-pie -DDEBUG_LEVEL=0
-#          Before running make, you must have      #
+# LD_OPTS = libfloatimg.a -pg -lm
 #          a look to the 'build.sh' script !       #
 ####################################################
-COPT = -Wall -Wextra -fpic -g  -no-pie -DDEBUG_LEVEL=0
+LIB_DIR = build/lib
 LDOPT = libfloatimg.a -g -lm 
-all:	essai
+OBJ_DIR = build/obj
-#---------------------------------------------------------------
+STATIC_LIB = $(LIB_DIR)/libfloatimg-lib.a
-essai:		essai.c libfloatimg.a floatimg.h Makefile
+DYN_LIB = $(LIB_DIR)/libfloatimg.so
 	gcc $(COPT) $< $(LDOPT) -lpnglite -lz -o $@
-install:
+VERBOSITY = 0
 	@echo "=== Use the 'install.sh' script ==="
-#---------------------------------------------------------------
+all: 	lib funcs tools v4l2
-TOTAR = *.[ch] Makefile *.sh *.md 			\
+# shared: $(DYN_LIB)
 	doc/the*.tex doc/mk*.sh	doc/*.txt		\
 	funcs/*.[ch] funcs/Makefile			\
 	tools/*.[ch] tools/*.sh tools/README.md tools/Makefile \
 	v4l2/*.[ch] v4l2/Makefile			\
 	scripts/*.sh scripts/README.md			\
 	lib/*.[ch] lib/Makefile
-lines:          $(TOTAR)
+# $(DYN_LIB): lib funcs
 	@wc $(TOTAR) | sort -n
-tarball:        $(TOTAR)
+lib:
-	date > tarball
+	$(MAKE) -C src/lib all
-	ls $(TOTAR) | sed 's/^/FloatImg\//'  > MANIFEST
+
-	( cd .. ; tar zcvf floatimg.tar.gz `cat FloatImg/MANIFEST` )
+funcs:	lib
 	$(MAKE) -C src/funcs
 	# link lib & funcs for shared library
 	echo "int verbosity = $(VERBOSITY);" >  $(OBJ_DIR)/verbosity.c
 	gcc -c $(OBJ_DIR)/verbosity.c -o $(OBJ_DIR)/verbosity.o
 	gcc -shared $(OBJ_DIR)/*.o -lnetpbm -lpnglite -lcfitsio -ltiff	-lz -lm -o $(DYN_LIB)
 tools: lib
 	mkdir -p build/bin
 	$(MAKE) -C src/tools
 v4l2:
 	mkdir -p build/bin
 	$(MAKE) -C src/v4l2
 clean:
 	$(MAKE) -C src/lib clean
 	$(MAKE) -C src/funcs clean
 	$(MAKE) -C src/tools clean
 	$(MAKE) -C src/v4l2 clean
 	rm -rf "./build"
 install: all
 	cp src/floatimg.h /usr/local/include
 	cp build/lib/* /usr/local/lib
 	cp build/bin/* /usr/local/bin
 # all:	essai
 # #---------------------------------------------------------------
 # essai:		essai.c libfloatimg.a floatimg.h Makefile
 # 	gcc $(COPT) $< $(LDOPT) -lpnglite -lz -o $@
 # #---------------------------------------------------------------
 # TOTAR = *.[ch] Makefile *.sh *.md 			\
 # 	doc/the*.tex doc/mk*.sh	doc/*.txt		\
 # 	funcs/*.[ch] funcs/Makefile			\
 # 	tools/*.[ch] tools/*.sh tools/README.md tools/Makefile \
 # 	v4l2/*.[ch] v4l2/Makefile			\
 # 	scripts/*.sh scripts/README.md			\
 # 	lib/*.[ch] lib/Makefile
 # lines:          $(TOTAR)
 # 	@wc $(TOTAR) | sort -n
 # tarball:        $(TOTAR)
 # 	date > tarball
 # 	ls $(TOTAR) | sed 's/^/FloatImg\//'  > MANIFEST
 # 	( cd .. ; tar zcvf floatimg.tar.gz `cat FloatImg/MANIFEST` )
 # #---------------------------------------------------------------
 #---------------------------------------------------------------
--- a/README.md
+++ b/README.md
@ -1,3 +1,14 @@
 # FloatImg4PythonBinding
 Un fork de la galactique bibliothèque FloatImg de tTh, réaménagé pour permettre une utilisation depuis Python avec l'embryonnaire binding https://git.tetalab.org/Mutah/python-FloatImg/ (seulement sur la branche develop pour le moment)
 Pas de révolution mais :
 - production d'une bibliothèque partagée
 - arborescence remanié : les meubles ont changés de place : les sources sont dans `src`, les expérimentations dans `extra` et les binaires sont produits dans `build`
 - build system : un Makefile racine avec des cibles générales : `all` pour tout builder, `lib` pour la bibliothèque de base, `funcs`
 # Traitement des images en virgule flottante.
 C'est d"abord un ensemble de fonctions pour traiter des images avec une énorme dynamique
@ -7,6 +18,7 @@ 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)
@ -14,27 +26,14 @@ 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 
-[Libera.Chat](https://libera.chat/)...
+[Freenode](https://webchat.freenode.net/)...
 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. 
-## *Show us the code !*
+*En avant vers l'infini, et au-delà...*
 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
@ -42,41 +41,22 @@ Bien entendu, avant tout, il faut installer quelques outils et
 dépendances. Je vais tenter de les lister dans le plus grand
 désordre (à la sauce Debian) :
-```
+```bash
-apt  install  libtiff-dev
+sudo apt install libtiff-dev libpnglite-dev liblo-dev libv4l2-dev libcfitsio-dev libnetpbm-dev
-apt  install  libpnglite-dev
+```
-apt  install  liblo-dev
+
-apt  install  libv4l2-dev
+Sauce Ubuntu :
-apt  install  libcfitsio-dev
+
-apt  install  libnetpbm-dev
+```bash
-apt  install  libncurses-dev
+sudo apt  install  libtiff-dev libpnglite-dev liblo-dev libv4l-dev libcfitsio-dev libnetpbm10-dev libncurses5-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, pour analyser des données,
+- gnuplot
- ImageMagick, parce que Brunus aime ça,
+- ImageMagick
- LaTeX, pour la (trop maigre) documentation.
+- LaTeX
 ## Documentation
@ -84,10 +64,4 @@ Encore trop légère, mais déja [présente](doc/).
 C'est à vous de compiler le
 [PDF](http://la.buvette.org/photos/cumul/the_floatimg_hack.pdf)
 ## TODO
 https://berthub.eu/articles/posts/always-do-this-floating-point/
 ## Conclusion
 *Your mileage may vary...*
--- a/build.sh
+++ b/build.sh
@ -1,41 +0,0 @@
 #!/bin/bash
 set -e ; set -u
 # ------------------------------------------------------------------
 function build
 {
 echo "============= $1 =============="
 curdir=${PWD}
 cd $1
 make 
 error=$?
 cd ${curdir}
 if [ ${error} -ne 0 ]
 then
 	echo "=== error on $1 = ${error}"
 	exit 1
 fi
 }
 # ------------------------------------------------------------------
 build lib
 build funcs
 build tools
 build v4l2
 build Fonderie
 # ------------------------------------------------------------------
 echo "========== Project root ==============="
 make
 # ------------------------------------------------------------------
--- a/contrib/.gitignore
+++ b/contrib/.gitignore
@ -1,14 +0,0 @@
 fimg2povhf
 demo_fmorph
 toto
 core
 *.tga
 *.png
 *.pnm
 *.gif
 *.fimg
 *.mp4
--- a/contrib/Makefile
+++ b/contrib/Makefile
@ -1,18 +0,0 @@
 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 $< $@
 # --------------------------------------------------------
--- a/contrib/README.md
+++ b/contrib/README.md
@ -1,14 +0,0 @@
 # 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.
--- a/contrib/demo_fmorph.c
+++ b/contrib/demo_fmorph.c
@ -1,116 +0,0 @@
 /*
 *		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;
 }
 /* ~~~ -------------------------------------------------------------- +++ */
--- a/contrib/do_eff_spass.sh
+++ b/contrib/do_eff_spass.sh
@ -1,163 +0,0 @@
 #!/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]"
--- a/contrib/fimg2povhf.c
+++ b/contrib/fimg2povhf.c
@ -1,116 +0,0 @@
 /*
 *		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;
 }
 /* ------------------------------------------------------------------ */
--- a/contrib/raytrace.sh
+++ b/contrib/raytrace.sh
@ -1,31 +0,0 @@
 #!/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
--- a/contrib/scene.pov
+++ b/contrib/scene.pov
@ -1,41 +0,0 @@
 /*    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 }
--- a/doc/mkgraf.sh
+++ b/doc/mkgraf.sh
@ -1,14 +1,7 @@
 #!/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__
@ -31,8 +24,6 @@ __EOF__
 wc $OUT
 #	---------------------------------------------------
 OUT="cos010.tex"
 gnuplot << __EOF__
@ -54,5 +45,3 @@ plot					\
 __EOF__
 wc $OUT
 #	---------------------------------------------------
--- a/doc/the_floatimg_hack.tex
+++ b/doc/the_floatimg_hack.tex
--- a/experiment/.gitignore
+++ b/experiment/.gitignore
@ -1,14 +0,0 @@
 *.fimg
 *.o
 *.pnm
 *.data
 assemblage
 extracteur
 fimg2obj
 mnt
 movepixels
 muxplanes
 tcache
--- a/experiment/Makefile
+++ b/experiment/Makefile
@ -1,40 +0,0 @@
 #
 #  some ugly experiments, do not use in production
 #
 COPT = -Wall -Wextra -fpic -g -DDEBUG_LEVEL=0 -lm
 DEPS = ../floatimg.h  ../libfloatimg.a Makefile
 LIBS = ../libfloatimg.a -ltiff -lpnglite -lcfitsio -lm
 all:	assemblage muxplanes movepixels mnt
 # ---------------------------------------------------------
 assemblage:	assemblage.c ${DEPS} 
 	gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@
 muxplanes:	muxplanes.c ${DEPS}
 	gcc $(COPT) $<   ${LIBS} -o $@
 movepixels:	movepixels.c ${DEPS}
 	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
 mnt:		mnt.c ${DEPS}
 	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
 fimg2obj:	fimg2obj.c $(DEPS)
 	gcc $(COPT) $<  ../libfloatimg.a ${LIBS} -o $@
 # ---------------------------------------------------------
 #			CACHE ENGINE (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 $@
--- a/experiment/README.md
+++ b/experiment/README.md
@ -1,29 +0,0 @@
 # Expérimentations ÀLC
 Attention, tout ce qui se trouve dans ce répertoire ne sont que des
 essais. Certains aboutissent, et sont migrés vers `lib/`, `funcs/` ou
 `tools/`, d'autre échouent et restent trainer dans le coin en attente
 du retour de l'inspiration.
 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).
--- a/experiment/cachengn.c
+++ b/experiment/cachengn.c
@ -1,145 +0,0 @@
 /*
 *		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;
 }
 /* ------------------------------------------------------------ */
--- a/experiment/cachengn.h
+++ b/experiment/cachengn.h
@ -1,29 +0,0 @@
 /*
 *		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);
--- a/experiment/fimg2obj.c
+++ b/experiment/fimg2obj.c
@ -1,67 +0,0 @@
 /*
 *		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;
 }
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
--- a/experiment/mnt.c
+++ b/experiment/mnt.c
@ -1,239 +0,0 @@
 /*
 *	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;
 }
 /* ------------------------------------------------------------------- */
--- a/experiment/movepixels.c
+++ b/experiment/movepixels.c
@ -1,156 +0,0 @@
 /*
 *		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;
 }
 /* ------------------------------------------------------------------- */
--- a/experiment/muxplanes.c
+++ b/experiment/muxplanes.c
@ -1,113 +0,0 @@
 /*
 *		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;
 }
 /* --------------------------------------------------------------- */
--- a/experiment/remotegrab.c
+++ b/experiment/remotegrab.c
--- a/experiment/tcache.c
+++ b/experiment/tcache.c
@ -1,49 +0,0 @@
 /*
 *		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;
 }
 /* ------------------------------------------------------------ */
--- a/experiment/tripla.sh
+++ b/experiment/tripla.sh
@ -1,24 +0,0 @@
 #!/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
--- a/extras/Fonderie/Makefile
+++ b/extras/Fonderie/Makefile
@ -7,12 +7,11 @@ 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 utilfuncs.o
+	filterstack.o single.o
 DEPS = 	../floatimg.h						\
 	../libfloatimg.a					\
 	fifo.h crapulator.h metriques.h glitches.h sfx.h	\
-	filterstack.h crapdef.h crapstr.h single.h utilfuncs.h
+	filterstack.h crapdef.h crapstr.h single.h
 all:	fonderie interpolator singlepass t
@ -41,19 +40,19 @@ singlepass:	singlepass.c ${DEPS} ${OBJS} Makefile
 #	some files are magically generated, sorry.
 #
 crapdef.h:	crapulors.liste Makefile craplist2h.awk
-	< $< ./craplist2h.awk > $@
+	./craplist2h.awk   < $< | tee $@
 crapstr.h:	crapulors.liste Makefile craplist2str.awk
-	< $< ./craplist2str.awk > $@
+	./craplist2str.awk < $< | tee $@
 # ---------------------------------------------------------
 #
 #	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 $(DEPS) Makefile
+fifo.o:	fifo.c fifo.h Makefile
 	gcc ${COPT} -c $<
 sfx.o:	sfx.c ${DEPS} Makefile
@ -71,7 +70,4 @@ metriques.o:	metriques.c metriques.h Makefile
 glitches.o:	glitches.c glitches.h Makefile
 	gcc ${COPT} -c $<
 utilfuncs.o:	utilfuncs.c utilfuncs.h Makefile
 	gcc ${COPT} -c $<
 # ---------------------------------------------------------
--- a/extras/Fonderie/README.md
+++ b/extras/Fonderie/README.md
@ -3,14 +3,12 @@
 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 spatio-temporel. 
+de **films flous** dans le domaine spacio-temporel. 
 À l'heure actuelle, il y a plusieurs programmes distincts. Le premier
 (fonderie) fait une moyenne mobile sur N images consécutives,
-le second (interpolator) fait un fondu-enchainé de N pas
+et 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...
@ -22,15 +20,16 @@ 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, utilisable dans une chaine de filtres. 
+Ces filtres ont chacun un nom et un numéro. que l'on peut (en théorie)
 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
+Une chaine de filtres est constituée d'une liste de nom ou de numéro
 de filtre, séparés par le caractère `:`, une façon de faire très
-classique dans notre univers, en fait.
+classique dans notre univers, en fait. Et si on veut prendre des risques,
 on doit continuer à appeler les filtres par leur numéro, jdçjdr.
-`mirsplit:ctr2x2:killlines`
+`mirsplit:ctr2x2:3:killlines`
 Nous allons donc voir quelques exemples un peu plus loin.
@ -71,14 +70,12 @@ GRABDIR="/spool/tth/fonderie"
 FONDEUR="$HOME/Devel/FloatImg/Fonderie/fonderie"
 GLOB=${GRABDIR}'/?????.fimg'
-${FONDEUR} -I "$GLOB" -E cos01:trinitron -F classtrial -T 30
+${FONDEUR} -I "$GLOB" -E cos01:25 -T 30 -F 2:classtrial
 ```
 Par défaut le répertoire où sont exportées les images est nommé
 `p8/` et il doit être là, c'est donc à vous de le créer.
 Votre machine va maintenant mouliner avec entrain et persévérance,
 puis
-ensuite il vous suffira d'encoder toutes les images générées dans
+ensuite il suffit d'encoder toutes les images générées dans
 `p8/` (répertoire de sortie par défaut)
 avec une incantation de ffmpeg :
@ -98,7 +95,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 à nos pixels
+pour voir le genre de traitement que l'on fait subir à nox pixels
 flottants.
 ## Interpolator
@ -115,8 +112,8 @@ usage:
        interpolator [options] <inglob> <outdir> <nbsteep>
 options:
        -S nn           mysterious sort
-        -E foo:bla:kr   input  filter chain
+        -E i:bla:k      input  filter chain
-        -F name:just    output filter chain
+        -F name:j       output filter chain
        -L              list available filters
        -v              increase verbosity
 ```
@ -133,15 +130,12 @@ 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**
--- a/extras/Fonderie/craplist2h.awk
+++ b/extras/Fonderie/craplist2h.awk
@ -6,19 +6,18 @@
 #
 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
 	{
-	name = sprintf("CR_%s", $2)
+	printf "#define    CR_%s    (%d)\n", $2, $1
 	printf "#define    %-15s    (%d)\n", name, $1
 	}
 END	{
-	print "\n// generated file, do not edit by hand !"
+	print "// generated file, do not edit by hand !"
 	}
--- a/extras/Fonderie/craplist2str.awk
+++ b/extras/Fonderie/craplist2str.awk
@ -0,0 +1,27 @@
 #!/usr/bin/awk -f
 #
 #		this utility script make a file who
 #		is includet by 'crapulator.c'
 #
 BEGIN	{
 	print "// -----------------------------------"
 	print "// generated file, do not edit by hand";
 	print "// -----------------------------------"
 	print "Crapulor CrapL[] = {";
 	}
 #		$1 is the badly brain-designed numeric id
 #		$2 is the user name of the filter
 #		$3 and $4 are two not used parameters
 #
 	{
 	printf "   { CR_%s, \"%s\", %d, %f }, // id=%d\n",
                        $2,    $2,   $3, $4,           $1;
 	}
 END	{
 	print "   { -1, NULL }"
 	print " };"
 	print "// generated file, do not edit by hand"
 	}
--- a/extras/Fonderie/crapulator.c
+++ b/extras/Fonderie/crapulator.c
@ -4,7 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <string.h>
 #include  <unistd.h>
@ -82,7 +81,7 @@ FloatImg		img;
 int 			foo, retval;
 FimgFilter3x3		*pfiltre;
-static FimgFilter3x3	lowpass = {
+FimgFilter3x3	lowpass = {
 		{
 		1.0,	2.0,	1.0,
 		2.0,	4.0,	2.0,
@ -91,8 +90,7 @@ static FimgFilter3x3	lowpass = {
 	16.0,	0.0
 	};
-static FimgFilter3x3	hipass = {
+FimgFilter3x3	hipass = {
 	/* there was a bug with this filter */
 		{
 		-1.0,	-1.0,	-1.0,
 		-1.0,	 9.0,	-1.0,
@ -101,12 +99,11 @@ static FimgFilter3x3	hipass = {
 	1.0,	0.0
 	};
-static FimgFilter3x3	diagonal = {
+FimgFilter3x3	diagonal = {
 	/* there was a bug with this filter */
 		{
-		4.0,	1.0,	0.0,
+		2.0,	1.0,	0.0,
 		1.0,	0.0,	-1.0,
-		0.0,	-1.0,	-4.0,
+		0.0,	-1.0,	-2.0,
 		},
 	1.0,	0.0
 	};
@ -154,150 +151,6 @@ 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
@ -416,28 +269,19 @@ 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, 120);
+		retval = des_bords_sombres_b(image, 160);
 		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;
@ -454,72 +298,22 @@ 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);
@ -555,26 +349,14 @@ 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
 }
 /* -------------------------------------------------------------- */
--- a/extras/Fonderie/crapulator.h
+++ b/extras/Fonderie/crapulator.h
--- a/extras/Fonderie/crapulors.liste
+++ b/extras/Fonderie/crapulors.liste
@ -27,26 +27,10 @@
 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
-46	pixelizh	1	1.111
+99	message		1	1.0
 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
--- a/extras/Fonderie/essai.sh
+++ b/extras/Fonderie/essai.sh
--- a/extras/Fonderie/fifo.c
+++ b/extras/Fonderie/fifo.c
@ -5,7 +5,6 @@
 */
 #include  <stdio.h>
 #include  <string.h>
 #include  <stdint.h>
 #include  <stdlib.h>
 #include  <malloc.h>
@ -26,7 +25,7 @@ extern	int		verbosity;
 static	A_Fifo		g_fifo;
 /* -------------------------------------------------------------- */
-static inline int big_adder(FloatImg *from, FloatImg *to)
+static int big_adder(FloatImg *from, FloatImg *to)
 {
 int		size, idx;
@ -87,10 +86,10 @@ return 0;
 */
 int export_fifo(char *fname, int notused)
 {
-int		foo;
+int		foo, type;
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
+fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, step);
 #endif
 foo = faire_la_somme(&g_fifo, NULL, 1);
@ -118,7 +117,7 @@ return 0;
 int insert_picture(FloatImg *src)
 {
 FloatImg	*dst;
-int		nbre;
+int		nbre, foo;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p )\n", __func__, src);
--- a/extras/Fonderie/fifo.h
+++ b/extras/Fonderie/fifo.h
--- a/extras/Fonderie/filterstack.c
+++ b/extras/Fonderie/filterstack.c
@ -4,7 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <string.h>
 #include  <ctype.h>
 #include  <alloca.h>
--- a/extras/Fonderie/filterstack.h
+++ b/extras/Fonderie/filterstack.h
--- a/extras/Fonderie/fonderie.c
+++ b/extras/Fonderie/fonderie.c
@ -4,13 +4,11 @@
 #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"
@ -109,7 +107,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];
-if (verbosity) fprintf(stderr, "first image size %dx%d\n", width, height);
+fprintf(stderr, "first image size %dx%d\n", width, height);
 fimg_create(&input, width, height, 3);
@ -121,10 +119,10 @@ if (foo) {
 	exit(1);
 	}
 maxvalue = fimg_get_maxvalue(&input);
-if (verbosity) fprintf(stderr, "first image maxvalue %f\n", maxvalue);
+fprintf(stderr, "first image maxvalue %f\n", maxvalue);
 foo = create_fifo(szfifo, width, height, FIMG_TYPE_RGB);
-if (verbosity) fprintf(stderr, "init fifo (%d slots) = %d\n", szfifo, foo);
+fprintf(stderr, "init fifo (%d slots) --> %d\n", szfifo, foo);
 /* XXX inject a few strange pics in the fifo */
 insert_blank(&input, blk, outdir);
@ -187,12 +185,10 @@ 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 (default p8/)");
+puts("\t-O\toutput directory");
 puts("\t-T\tfifo size");
 puts("\t-v\tincrease verbosity");
 if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
 exit(0);
 }
 /* -------------------------------------------------------------- */
@ -203,12 +199,13 @@ int		fifosize = 10;
 char		*in_pattern = "capture/?????.fimg";
 char		*out_dir = "p8";
 int		outfmt = FILE_TYPE_PNG;
-int		blanks = 10;
+int		blanks = 20;
 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) {
@ -231,7 +228,6 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
 				break;
 		case 'v':	verbosity++;
 				break;
 		default:	exit(1);
 		}
 	}
@ -240,16 +236,6 @@ 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);
@ -271,7 +257,7 @@ if (verbosity > 1) {
 foo = demarre_la_machine(in_pattern, out_dir, fifosize, outfmt, blanks);
-fprintf(stderr, "retour du bigrun de la machine -> %d\n", foo);
+fprintf(stderr, "retour du big-run de la machine -> %d\n", foo);
 return 0;
 }
--- a/extras/Fonderie/glitches.c
+++ b/extras/Fonderie/glitches.c
@ -7,7 +7,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <string.h>
 #include  <math.h>
@ -151,38 +150,36 @@ 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, "WARNING %s: %dx%d bad dims\n", __func__,
+	fprintf(stderr, "%s: %d%d bad dims\n", __func__,
 				picture->width, picture->height);
 	// return -1;
 	}
-for (y=16; y<picture->height-16; y+=16) {
+for (y=0; y<picture->height; y+=16) {
-	for (x=16; x<picture->width-16; x+=16) {
+	for (x=0; x<picture->width; 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);
 			}
 		}
 	}
--- a/extras/Fonderie/glitches.h
+++ b/extras/Fonderie/glitches.h
--- a/extras/Fonderie/interpolator.c
+++ b/extras/Fonderie/interpolator.c
@ -10,14 +10,12 @@
 */
 #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"
@ -55,14 +53,10 @@ char		*filename;
 IdxValue	*idxvalues;
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %p %d %p)\n", __func__, ptr_glob,
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, ptr_glob,
-				ptr_idxval, method, p_average);
+				ptr_idxval, method);
 #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 */
@ -71,7 +65,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;
@ -109,7 +103,7 @@ if (verbosity > 1) {
 average /= (double)nombre;
 *p_average = average;
-fprintf(stderr, "\naverage of ??? is %f\n", average);
+fprintf(stderr, "\naverage %f\n", average);
 return 0;
 }
@ -127,7 +121,7 @@ int		foo, idx, ipng, w, h, step;
 int		curpix;
 int		iarray[3];
 char		*cptr, line[200];
-float		coef;
+float		coef, value;
 double		meanmetric;
 IdxValue	*idx_values;			/* gni? */
@ -141,8 +135,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, ABEND\n", __func__);
+	fprintf(stderr, "%s : no file found, aborting\n", __func__);
-	exit(1);
+	return -1;
 	}
 idx_values = NULL;
@ -160,7 +154,7 @@ if (FIMG_TYPE_RGB != iarray[2]) {
 	}
 w = iarray[0], h = iarray[1];
-if (verbosity) fprintf(stderr, "first image size : %dx%d\n", w, h);
+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);
@ -177,10 +171,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, "\n%s: load %s from dump -> %d\n", __func__,
+		fprintf(stderr, "load %s from dump -> %d\n", cptr, foo);
 						cptr, foo);
 		continue;
 		}
 	value = idx_values[idx].value;
 	/* here was the input filter */
 	foo = filterstack_run(0, &B, 0);
@ -241,7 +235,9 @@ puts("\t-S nn\t\tmysterious sort");
 puts("\t-L\t\tlist available filters");
 puts("\t-v\t\tincrease verbosity");
-if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
+if (verbosity) {
 	list_crapulors("available filters");
 	}
 exit(0);
 }
@ -256,11 +252,10 @@ int		opt;
 int		sort = 0;
 char		*InFchain  = "0";
 char		*OutFchain = "0";
 char		*out_dir = "p8/";
-fprintf(stderr, "*** %s\n\tcompiled on %s %s\n", argv[0],
+fprintf(stderr, "*** %s : compiled by tTh, %s %s\n", __FILE__,
 			__DATE__, __TIME__);
-if (verbosity) fimg_print_version(2);
+fimg_print_version(2);
 #if DEBUG_LEVEL
 /* this is for the debug off calling shellscript */
@ -279,7 +274,6 @@ 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);
 		}
 	}
@ -292,18 +286,6 @@ 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);
@ -320,14 +302,13 @@ 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) {
-	fputs("=========================\n", stderr);
+	puts("=========================");
 	filterstack_list(0, __FILE__);
 	filterstack_list(1, __FILE__);
-	fputs("=========================\n", stderr);
+	puts("=========================");
 	}
 nbrsteps = atoi(argv[optind+2]);
--- a/extras/Fonderie/metriques.c
+++ b/extras/Fonderie/metriques.c
@ -4,8 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  "../floatimg.h"
 #include  "metriques.h"
@ -86,9 +84,6 @@ 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;
@ -100,16 +95,8 @@ 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];
--- a/extras/Fonderie/metriques.h
+++ b/extras/Fonderie/metriques.h
--- a/extras/Fonderie/notes.md
+++ b/extras/Fonderie/notes.md
--- a/extras/Fonderie/sfx.c
+++ b/extras/Fonderie/sfx.c
@ -5,7 +5,6 @@
 */
 #include  <stdio.h>
 #include  <string.h>
 #include  <stdint.h>
 #include  <stdlib.h>
 #include  <malloc.h>
 #include  <math.h>
@ -21,88 +20,6 @@
 */
 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 !
@ -129,47 +46,21 @@ 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;
-// fprintf(stderr, ">>> %s ( %p  %d,%d,%d,%d )\n", __func__, pimg,
+for (y=pos[1]; y<pos[1]+pos[3]; y++) {
 //			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=0; x<5; x++) {
+	for (x=pos[0]+2; x<pos[0]+pos[2]-2; x++) {
-		off = pline + (x+pos[0]);
+		off = pline + x;
 		/* 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+5]  = fvals[1];
+		pimg->G[off] = fvals[1];
-			pimg->B[off+10] = fvals[2];
+		pimg->B[off] = fvals[2];
 			}
 		}
 	}
 return 0;
 }
 /*
 *	need more explanation, need more work
 */
 int trinitron(FloatImg *pimg, int notused)
 {
 int		x, y, coo[4], foo;
@ -179,36 +70,20 @@ float		vals[3];
 fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
 #endif
-/*	    XXX  CRITICAL BUG  XXX
+#define STP  16			/* stepd for x & y axex */
 *
 *	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-STP; y+=STP) {
+for (y=0; y<pimg->height; y+=STP) {
 	coo[1] = y;
-	for (x=0; x < pimg->width-STP; x+=STP) {
+	for (x=0; x<pimg->width; 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;
 }
 /* -------------------------------------------------------------- */
@ -436,40 +311,19 @@ return 0;
 /* -------------------------------------------------------------- */
 /* nouveau Mon 10 May 2021 08:46:02 PM CEST
 *	chez Eric 1KA						*/
-int des_bords_sombres_b(FloatImg *pimg, int nbre)
+int des_bords_sombres_b(FloatImg *pimg, int offset)
 {
 int		idx, x, foo;
 float		coef, *fptr;
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, nbre);
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, offset);
 #endif
-for (idx=0; idx<nbre; idx++) {
+if (offset<0 || offset>=pimg->width) {
-
+	fprintf(stderr, "%s: offset %d is bad\n", __func__, offset);
-	coef = (float)idx / (float)nbre;
+	return -66;
 	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;
 	}
-// fprintf(stderr, "WARNING: %s badly implemented\n", __func__);
+return -1;
 return 0;
 }
 /* -------------------------------------------------------------- */
 /*
--- a/extras/Fonderie/sfx.h
+++ b/extras/Fonderie/sfx.h
@ -3,11 +3,8 @@
 *	---------------------------------------------------
 */
 int graylevel2popcolors(FloatImg *src, FloatImg *dst, int k);
 int incrustation_vignette(FloatImg *src, FloatImg *dst, int k);
 int poke_sup_rb_g(FloatImg *src, FloatImg *dst);
 int trinitron(FloatImg *pimg, int notused);
--- a/extras/Fonderie/single.c
+++ b/extras/Fonderie/single.c
@ -1,6 +1,5 @@
 /*
-		SINGLE PICZ PROCESSOR
+		SINGLE
 	experimental and/or testing code, do not use in
 	production.
@ -9,8 +8,6 @@
 #include   <stdio.h>
 #include   <string.h>
 #include   <sys/stat.h>
 #include   <stdint.h>
 #include  <sys/time.h>
 #include   "../floatimg.h"
@ -26,7 +23,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;
@ -51,7 +48,7 @@ if (foo) {
 	return -2;
 	}
 if (S_IFDIR != (stbuf.st_mode & S_IFMT)) {
-	fprintf(stderr, "%s: %s must be a directory\n", __func__, dest);
+	fprintf(stderr, "! %s must be a directory\n", dest);
 	return -3;
 	}
@ -101,6 +98,7 @@ 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) {
--- a/extras/Fonderie/single.h
+++ b/extras/Fonderie/single.h
--- a/extras/Fonderie/singlepass.c
+++ b/extras/Fonderie/singlepass.c
@ -6,14 +6,12 @@
 #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"
@ -26,9 +24,6 @@
 int		verbosity;
 /* ----------------------------------------------------------- */
 /*
 *	parameter 'duplic' is the repetition factor
 */
 int run_the_singlepass(char *globber, char *destdir, int duplic,
 					int fchain, int outfmt)
 {
@ -39,11 +34,11 @@ char		*fname;
 double		elapsed;
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' '%s'  %d  %d %d )\n", __func__,
+fprintf(stderr, ">>> %s ( '%s' '%s' %d %d )\n", __func__,
-				globber, destdir, duplic, fchain, outfmt);
+				globber, destdir, fchain, outfmt);
 #endif
-if (verbosity) filterstack_list(fchain, "Run the single pass");
+// filterstack_list(fchain, "Run the single pass");
 (void)fimg_timer_set(0);
@ -85,21 +80,17 @@ 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 && verbosity) {
+	if (0 == idx) {
-		fprintf(stderr, "\tfirst image size %dx%d\n",
+		fprintf(stderr, "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) {
@ -115,6 +106,10 @@ 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);
 			}
 		}
 	}
@ -123,7 +118,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",
@ -160,9 +155,9 @@ char		*outdir      =   "./p8";
 int		do_xper = 0;
 int		repeat = 1;
-fprintf(stderr, "*** %s\n\tcompiled %s %s\n", argv[0],
+fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
                        __DATE__, __TIME__);
-if (verbosity) fimg_print_version(2);
+fimg_print_version(2);
 if (argc < 2) {
 	fprintf(stderr, "\t/!\\ %s is option driven\n", argv[0]);
@ -192,6 +187,7 @@ while ((opt = getopt(argc, argv, "hF:g:LO:r:svx")) != -1) {
 			fprintf(stderr, "%s ABEND\n", argv[0]);
 			exit(1);
 		}
 	}
 if (repeat < 1) {
@ -199,13 +195,6 @@ 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);
@ -222,12 +211,9 @@ 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, "\tRun the single pass --> %d\n", foo);
+fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
 return 0;
 }
--- a/extras/Fonderie/t.c
+++ b/extras/Fonderie/t.c
@ -4,7 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <unistd.h>
 #include  <string.h>
 #include  <glob.h>
@ -16,8 +15,6 @@
 #include  "crapulator.h"
 #include  "single.h"
 #include  "utilfuncs.h"
 /* ----------------------------------------------------------- */
 int		verbosity;
@ -30,30 +27,6 @@ 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)
@ -62,16 +35,11 @@ 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, "%s: err %d create from dump\n", __func__, foo);
+	fprintf(stderr, "err %d create image\n", foo);
 	exit(1);
 	}
@ -104,6 +72,8 @@ 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)
 {
@ -190,24 +160,23 @@ puts("\t-s\tdo single test");
 exit(0);
 }
 /* ----------------------------------------------------------- */
-int experiment(char *fname)
+int experiment(void)
 {
 int		foo;
 FloatImg	image, dest;
-fprintf(stderr, "----- EXPERIMENT on '%s' -----\n", fname);
+fprintf(stderr, "EXPERIMENT\n");
-foo = fimg_create_from_dump(fname, &image);
+foo = fimg_create_from_dump("01137.fimg", &image);
 if (foo) {
-	fprintf(stderr, "%s: err %d on create_from_dump\n",
+	fprintf(stderr, "%s: err %d on create\n", __func__, foo);
 			__func__, foo);
 	return -1;
 	}
-foo = fimg_clone(&image, &dest, 0);
+foo = fimg_clone(&image, &dest, 1);
 foo = fimg_copy_data(&image, &dest);
-foo = poke_sup_rb_g(&image, &dest);
+incrustation_vignette(&image, &dest, 0);
 fprintf(stderr, "poke sup rb g --> %d\n", foo);
 fimg_export_picture(&dest, "foo.png", 0);
@ -249,25 +218,17 @@ 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(infile);
+	experiment();
 	return 0;
 	}
 if (do_single) {
--- a/extras/essai.c
+++ b/extras/essai.c
@ -5,7 +5,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <unistd.h>
 #include  <math.h>
 #include  <string.h>
@ -18,17 +17,14 @@ int		verbosity;
 void fait_un_dessin(FloatImg *dessin)
 {
 // fprintf(stderr, "je dessine dans %p\n", dessin);
 fimg_draw_something(dessin);
 }
 /* --------------------------------------------------------------------- */
-void help(void)
+void help(int k)
 {
 puts("Options :");
 puts("\t-d WxH\timage size");
 puts("\t-v\tincrease verbosity");
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@ -37,14 +33,14 @@ int main(int argc, char *argv[])
 {
 FloatImg	fimgA, fimgB;
 int		foo, opt;
-int		W = 640, H = 480;
+int		W = 800, H = 600;
 double		tb;
 while ((opt = getopt(argc, argv, "d:hv")) != -1) {
 	switch(opt) {
 		case 'd':	parse_WxH(optarg, &W, &H);
 				break;
-		case 'h':	help();		break;
+		case 'h':	help(0);		break;
 		case 'v':	verbosity++;		break;
 		}
 	}
@ -60,7 +56,7 @@ fimg_drand48(&fimgB, 100.0);
 foo = fimg_dump_to_file(&fimgB, "B.fimg", 0);
 fimg_timer_set(0);
-#define NBP 5
+#define NBP 500
 for (foo=0; foo<NBP; foo++) {
 	if (verbosity) {
 		printf("%5d / %5d\n", foo, NBP);
@ -70,9 +66,9 @@ for (foo=0; foo<NBP; foo++) {
 	// fimg_mul(&fimgA, &fimgB, &fimgA);
 	}
 tb = fimg_timer_get(0);
-fprintf(stderr, "%s = %.2f seconds, %.2f s/p\n", __func__, tb, tb/(double)NBP);
+fprintf(stderr, "%s = %f seconds\n", __func__, tb);
-foo = fimg_save_as_pnm(&fimgA, "out.pnm", 0);
+foo = fimg_save_as_pnm(&fimgA, "drand48.pnm", 0);
-foo = fimg_dump_to_file(&fimgA, "out.fimg", 0);
+foo = fimg_dump_to_file(&fimgA, "drand48.fimg", 0);
 fimg_destroy(&fimgA);
 fimg_destroy(&fimgB);
--- a/extras/experiment/Makefile
+++ b/extras/experiment/Makefile
@ -0,0 +1,15 @@
 #  experiments
 COPT = -Wall -fpic -g -DDEBUG_LEVEL=1 -lm
 DEPS = ../floatimg.h  ../libfloatimg.a Makefile
 LIBS = -ltiff -lpnglite -lcfitsio
 all:	assemblage extracteur
 assemblage:	assemblage.c ${DEPS} 
 	gcc $(COPT) $< ../libfloatimg.a $(LIBS) -o $@
 extracteur:	extracteur.c ${DEPS}
 	gcc $(COPT) $<  ../libfloatimg.a $(LIBS) -o $@
--- a/extras/experiment/README.md
+++ b/extras/experiment/README.md
@ -0,0 +1,6 @@
 # EXPÉRIMENTATION ÀLC
 ## ASSEMBLAGE
 ## EXTRACTEUR
--- a/extras/experiment/assemblage.c
+++ b/extras/experiment/assemblage.c
@ -4,7 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  "../floatimg.h"
@ -51,6 +50,7 @@ if (foo) {
 	return -1;
 	}
 foo =  fimg_export_picture(&grande, outname, 0);
 if (foo) {
 	fprintf(stderr, "%s: error %d export '%s'\n", __func__,
--- a/extras/experiment/essai.sh
+++ b/extras/experiment/essai.sh
--- a/extras/experiment/extracteur.c
+++ b/extras/experiment/extracteur.c
@ -0,0 +1,131 @@
 /*
 *		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;
 }
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
--- a/funcs/.gitignore
+++ b/funcs/.gitignore
@ -1,10 +0,0 @@
 tpnm
 t
 *.o
 *.png
 *.gif
 *.fits
 *.tiff
--- a/funcs/README.md
+++ b/funcs/README.md
@ -1,53 +0,0 @@
 # Fonctions
 Plein de fonctions qu'il serait bon de documenter :)
 ## Contours
 Détecter des contours est une activité respectable. Mais difficile.
 Une recherche dans la littérature s'impose.
 ## Exporter
 `fimg_exporter` est une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
 une image en fonction de l'extension du nom de fichier fourni.
 ### PNG
 __Attention__ : la bibliothèque `pnglite` actuellement utilisée pour lire
 les fichiers PNG n'accepte que certains types de fichiers.
 Et en particulier, elle brotche sur ceux produits par ImageMagick !
 ### FITS
 Ce [format de fichier](https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/c_user/node1.html)
 est utilisé en astronomie.
 Son support est actuellement minimaliste.
 ### DICOM
 https://en.wikipedia.org/wiki/DICOM et ça semble bien compliqué,
 donc ça reste pour le moment au stade de vague projet :(
 ## Sfx
 Effets spéciaux divers. 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.
--- a/funcs/decomprgb.c
+++ b/funcs/decomprgb.c
@ -1,157 +0,0 @@
 /*
 *	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;
 }
 /* == ---------------------------------------------------- == */
--- a/funcs/falsecolors.c
+++ b/funcs/falsecolors.c
@ -1,83 +0,0 @@
 /*
 *	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;
 }
 /* -------------------------------------------------------------- */
--- a/funcs/fimg-dicom.c
+++ b/funcs/fimg-dicom.c
@ -1,33 +0,0 @@
 /*
      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;
 }
 /* --------------------------------------------------------------------- */
--- a/funcs/fmorpho.c
+++ b/funcs/fmorpho.c
@ -1,89 +0,0 @@
 /*
  *			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;
 }
 /* --------------------------------------------------------------------- !*/
--- a/funcs/killrgb.c
+++ b/funcs/killrgb.c
@ -1,45 +0,0 @@
 /*
 *		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;
 }
 /* --------------------------------------------------------------------- */
--- a/funcs/pixelize.c
+++ b/funcs/pixelize.c
@ -1,101 +0,0 @@
 /*
 *		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;
 }
 /*   --------------------------------------------------------------   */
--- a/funcs/rectangle.c
+++ b/funcs/rectangle.c
@ -1,38 +0,0 @@
 /*
 *			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;
 }
 /* --------------------------------------------------------------------- */
--- a/funcs/sfx3.c
+++ b/funcs/sfx3.c
@ -1,99 +0,0 @@
 /*
 *		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;
 }
 /* -------------------------------------------------------------- */
--- a/funcs/sfx4.c
+++ b/funcs/sfx4.c
@ -1,120 +0,0 @@
 /*
 *		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;
 }
 /* -------------------------------------------------------------- */
--- a/funcs/thermocolor.c
+++ b/funcs/thermocolor.c
@ -1,67 +0,0 @@
 /*
 *		FLOATIMG
 *	fabriquer une pseudo-image thermique
 *
 * new: Wed Mar 20 16:55:09 UTC 2024 dans ma maison du Gers
 */
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <string.h>
 #include  <stdint.h>
 #include  "../floatimg.h"
 extern int		verbosity;
 /* --------------------------------------------------------------------- */
 /*
 *	parameter k in not used, but may be in the futur.
 */
 int fimg_auto_thermique(FloatImg *src, FloatImg *dst, int k)
 {
 // int		x, y, off;
 int		idx, surface;
 float		seuil, gray;
 double		graymean;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p  %p  %d )\n", __func__, src, dst, k);
 #endif
 if (0!=k) {
 	fprintf(stderr, "%s: k must be 0, was %d\n", __func__, k);
 	}
 surface = src->width * src->height;
 // fprintf(stderr, "surface = %d\n", surface);
 graymean = 0.0;
 for (idx=0; idx<surface; idx++) {
 	gray = src->R[idx] + src->G[idx] + src->B[idx];
 	graymean += (double)gray;
 	}
 seuil = (float) (graymean / surface);
 // fprintf(stderr, "graymean = %f   seuil = %f\n", graymean, seuil);
 /*
 *	please, explain this number brotching
 */
 for (idx=0; idx<surface; idx++) {
 	gray = src->R[idx] + src->G[idx] + src->B[idx];
 	if (gray > seuil) {
 		dst->R[idx] = gray - seuil;
 		dst->B[idx] = seuil / 8.0;
 		}
 	else	{
 		dst->G[idx] = gray;
 		dst->B[idx] = seuil / 8.0;
 		}
 	}
 return 0;
 }
 /* --------------------------------------------------------------------- */
--- a/install.sh
+++ b/install.sh
@ -1,7 +1,5 @@
 #!/bin/bash -v
 set -e ; set -u
 cp	libfloatimg.a 	/usr/local/lib
 cp	floatimg.h 	/usr/local/include
@ -10,8 +8,6 @@ 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		\
--- a/lib/README.md
+++ b/lib/README.md
@ -1,26 +0,0 @@
 # 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.
--- a/lib/alphachan.c
+++ b/lib/alphachan.c
@ -1,29 +0,0 @@
 /*
 *              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;
 }
 /* ---------------------------------------------------------------- */
--- a/lib/metadata.c
+++ b/lib/metadata.c
@ -1,164 +0,0 @@
 /*
 *              metadata.c
 *		----------
 *
 *	This is not a stable version. You must expect problems,
 *	and the first one was time_t 32 vs. 64 bits.
 *
 */
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <unistd.h>
 #include  <time.h>
 #include	<sys/time.h>
 #include  <string.h>
 #include  "../floatimg.h"
 extern int verbosity;           /* must be declared around main() */
 /* ---------------------------------------------------------------- */
 int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused)
 {
 int		foo;
 double		doubletime;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p '%s' 0x%08x )\n", __func__,
 				pmd, title, notused);
 #endif
 if (notused) {
 	fprintf(stderr, "notused was %d, must be 0 in %s\n",
 				notused, 		__func__);
 	}
 if (NULL != title) {
 	fprintf(stderr, "======== metadata for %s\n", title);
 	}
 if (verbosity) {
 	fprintf(stderr, "sizeof(metadata)     = %ld\n",    \
 				sizeof(FimgMetaData));
 	fprintf(stderr, "    Magic [%08x]\n", pmd->magic);
 	}
 /* SHOW TIMESTAMP HERE */
 fprintf(stderr, "secs from epoch      = %ld\n", pmd->timestamp.tv_sec);
 fprintf(stderr, "date & time          = %s",   ctime(&pmd->timestamp.tv_sec));
 doubletime = (double)pmd->timestamp.tv_sec +			\
 		(double)pmd->timestamp.tv_usec / 1e6;
 fprintf(stderr, "dtime of day         = %12.3f\n", doubletime);
 fprintf(stderr, "creator pid          = %ld\n", pmd->cpid);
 fprintf(stderr, "float value          = %.3f\n", pmd->fval);
 fprintf(stderr, "counter              = %d\n", pmd->count);
 fprintf(stderr, "id camera            = '%s'\n", pmd->idcam);
 fprintf(stderr, "origin               = 0x%x\n", pmd->origin);
 fputs("reserved words are:\n      ", stderr);
 for (foo=0; foo<8; foo++) {
 	fprintf(stderr, "     0x%08x", pmd->reserved[foo]);
 	if (3 == foo) fputs("\n      ", stderr);
 	}
 fputc('\n', stderr);
 return 0;
 }
 /* ---------------------------------------------------------------- */
 /*
 *	those values may be loaded from a config file ?
 */
 int fimg_default_metadata(FimgMetaData *pmd, int bla)
 {
 int			foo;
 struct timeval		tvl;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pmd, bla);
 #endif
 memset(pmd, 0, sizeof(FimgMetaData));
 /* set timestamp here ? */
 /* CHALLENGE ACCEPTED */
 memset(&tvl, 0, sizeof(struct timeval));
 foo = gettimeofday(&tvl, NULL);
 if (foo) {
 	/* error on get time of day ? */
 	perror("omg");
 	}
 else	{
 	if (verbosity > 1) {
 		fprintf(stderr, "%s : set TimeOfDay to  %12ld %8ld\n", \
 					__func__, tvl.tv_sec, tvl.tv_usec);
 		}
 	memcpy(&(pmd->timestamp), &tvl, sizeof(struct timeval));
 	}
 pmd->magic	   = MAGIC_MDATA;
 pmd->cpid          = getpid();		// we are the creator, no ?
 pmd->count         = 1;			// mmmm...
 pmd->fval          = 255.0;		// Ok
 strcpy(pmd->idcam, "<noname camera>");
 pmd->origin        = 0xdeadbeef;	// classic joke, sorry
 pmd->reserved[0]   = bla;
 pmd->reserved[7]   = 0x55445544;	// magic number is a crime
 return 0;
 }
 /* ---------------------------------------------------------------- */
 int fimg_get_metadata_from_file(char *fname, FimgMetaData *pmd)
 {
 FILE			*fp;
 FimgFileHead		filehead;
 FimgMetaData		metadata;
 int			foo;
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, fname, pmd);
 #endif
 if (NULL==(fp=fopen(fname, "r"))) {
 	perror(fname);
 	return -1;
 	}
 foo = fread(&filehead, sizeof(FimgFileHead), 1, fp);
 if (1 != foo) {
 	fprintf(stderr, "short read (%d) on %s (head)\n", foo, fname);
 	fclose(fp);
 	return -2;
 	}
 if (memcmp(filehead.magic, "FIMG", 4)) {
 	fprintf(stderr, "'%s' is not a fimg file.\n", fname);
 	fclose(fp);
 	return -3;
 	}
 if ('a' != filehead.magic[4]) {
 	fprintf(stderr, "file '%s' have no metadata.\n", fname);
 	fclose(fp);
 	return -4;
 	}
 foo = fread(&metadata, sizeof(FimgMetaData), 1, fp);
 if (1 != foo) {
 	fprintf(stderr, "short read on %s (metadata)\n", fname);
 	fclose(fp);
 	return -5;
 	}
 fclose(fp);		/* got all needed datas */
 if (MAGIC_MDATA != metadata.magic) {
 	fprintf(stderr, "%s: magic was %08X, wtf?\n", __func__,
 					metadata.magic);
 	return -4;
 	}
 memcpy(pmd, &metadata, sizeof(FimgMetaData));
 return 0;
 }
 /* ---------------------------------------------------------------- */
--- a/scripts/.gitignore
+++ b/scripts/.gitignore
@ -1,7 +0,0 @@
 *.fits
 *.tiff
 *.tif
 *.png
--- a/scripts/README.md
+++ b/scripts/README.md
@ -1,8 +1,7 @@
 # Exemples de scripts
 _Attention_, ce ne sont que des exemples, pas forcément adaptés
-à une utilisation dans le monde réel. Mais vous pouvez vous en
+à une utilisation dans le monde réel.
 inspirer pour vos usecases personnels.
 ## shoot.sh
@ -21,13 +20,5 @@ en dur dans le code.
 Comment générer des videos psychotiques avec un peu de bash.
 Ce script est expliqué dans la documentation PDF.
 ## capture.sh & conf.sh
 Ce [script](./capture.sh) sert à capturer une séquence d'image depuis
 une webcam.
 Deux choses à noter : il utilise un fichier de configuration
 (`source [./conf.sh](./conf.sh)) pour ajuster son fonctionnement, et il
 extrait juste une portion de l'image capturée. Une belle avancée,
 puisque cela ajoute quelques possibilités de recadrage dès
 la prise de vue.
--- a/scripts/capture.sh
+++ b/scripts/capture.sh
@ -1,30 +0,0 @@
 #!/bin/bash
 # 		CAPTURE
 source ./conf.sh
 DEVICE="/dev/video0"
 GOPT=" -v -s 1920x1080  -p 0 -n 10"
 OUTD=$GRABDIR
 TMPG="/dev/shm/tmpgrab.fimg"
 for idx in $(seq  0 2399)
 do
 	# take the picz
 	${GRAB} -d ${DEVICE} ${GOPT} -o ${TMPG}
 	# display $TMPG
 	# only take the good spot
 	fimg=$(printf "%s/%05d.fimg" ${OUTD} ${idx})
 	${EXTR}  -o ${fimg} ${TMPG} 800,600,560,240
 	# display ${fimg} ;  exit
 	echo
 	sleep $DELAY_GRAB
 done
--- a/scripts/conf.sh
+++ b/scripts/conf.sh
@ -1,34 +0,0 @@
 # Sat Jul  8 10:41:58 UTC 2023
 #
 #	location of some tools
 #
 GRAB="$HOME/Devel/FloatImg/v4l2/grabvidseq"
 MKFX="$HOME/Devel/FloatImg/tools/fimgfx"
 MDAT="$HOME/Devel/FloatImg/tools/fimgmetadata"
 EXTR="$HOME/Devel/FloatImg/tools/fimgextract"
 INTERPOLATOR="$HOME/Devel/FloatImg/Fonderie/interpolator"
 FONDERIE="$HOME/Devel/FloatImg/Fonderie/fonderie"
 SINGLEPASS="$HOME/Devel/FloatImg/Fonderie/singlepass"
 #
 #	working directories
 #
 GRABDIR="rush"
 GIFDIR="gif89a"
 #
 #	text plotting conf
 FONT="Noto-Sans-Bold"
 KERNING=1
 SIGNATURE="... tTh 2023 ..."
 #
 #	filter chains for fondulations
 #
 IF="cos01:colmixa:pow2"
 OF="shiftln0:liss3x3"
--- a/scripts/contrast-test.sh
+++ b/scripts/contrast-test.sh
@ -2,9 +2,9 @@
 CMDPATH="/usr/local/bin"
-WS="${HOME}/TMP"		# our workspace
+WS="./tmp"		# our workspace
-GRABOPT=" -d /dev/video0 -v -n 240 -p 0.04 "
+GRABOPT=" -d /dev/video0 -vu -n 240 -p 0.04 "
 GRAB=${WS}/"quux.fimg"
 COS01=${WS}/"cos01.fimg"
@ -15,9 +15,9 @@ POW2="${WS}/pow2.fimg"
 # --------- conversion fimg -> pnm
 f2p ()
 {
-dst=EC_$(basename $1 .fimg).pnm
+dst=$(basename $1 .fimg).pnm
 echo == converting $1 to $dst
-${CMDPATH}/fimg2pnm  $1 ${WS}/$dst
+${CMDPATH}/fimg2pnm  $1 $dst
 }
 # --------- capturer une image
@ -43,4 +43,4 @@ f2p $COS010
 # ----------- présentation finale
 #
 echo == Making gif89a
-convert -delay 40 ${WS}/EC_*.pnm foo.gif
+convert -delay 40 *.pnm foo.gif
--- a/scripts/demo-fimgfx.sh
+++ b/scripts/demo-fimgfx.sh
@ -1,27 +0,0 @@
 #!/bin/bash
 source="00000.fimg"
 tmpimg="/dev/shm/demofx.fimg"
 effects=$(fimgfx -l)
 for fx in $effects
 do
 	echo "============= " $fx
 	dst="${fx}.png"
 	echo "       " ${source} ${dst}
 	fimgfx -v ${fx} ${source} ${tmpimg}
 	convert $tmpimg				\
 		-fill black -stroke white	\
 		-strokewidth 1			\
 		-pointsize 34			\
 		-font "Noto-Sans-Bold"		\
 		-gravity South-East		\
 		-annotate +32+10 "${fx}"	\
 		${dst}
 done
--- a/scripts/demo-mkfimg.sh
+++ b/scripts/demo-mkfimg.sh
@ -1,13 +0,0 @@
 #!/usr/bin/env bash
 echo "=== make a lot of float img ==="
 MKFIMG="../tools/mkfimg"
 SIZE=" 640x480 "
 for type in $(${MKFIMG} -L)
 do
 	picname="/tmp/${type}.fimg"
 	echo $picname
 	${MKFIMG} -v -t $type $picname $SIZE
 done
--- a/scripts/echomix.sh
+++ b/scripts/echomix.sh
@ -26,9 +26,9 @@ for idx in $(seq 0 $NBRE)
 do
 	# build the two input filenames ...
 	#
-	imgA=$(printf "$SRCDIR/%05d.fimg" $idx)
+	imgA=$(printf "$SRCDIR/%04d.fimg" $idx)
 	vb=$(( $(( idx + OFFS )) % NBRE))
-	imgB=$(printf "$SRCDIR/%05d.fimg" $vb)
+	imgB=$(printf "$SRCDIR/%04d.fimg" $vb)
 	#	... and the output filename
 	#
--- a/src/floatimg.h
+++ b/src/floatimg.h
@ -1,88 +1,37 @@
 /*
 *			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	(245)
+#define		FIMG_VERSION	150
 #define		RELEASE_NAME	("noname")
 #define		PATCH_LEVEL	("aaaa")
 /* XXX add a test for stdint.h / uint32_t XXX */
 #include  <stdint.h>
 /*
- *		new 11 mars 2022, and a lot of iterations
+ *	in memory descriptor
 *		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 {
-	uint32_t	magic;
+	unsigned long	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 (short version)
+ *	fimg file header
 */
 typedef struct {
-	char		magic[8];	/* this is not an asciiz ! */
+	char		magic[8];
 	int32_t		w, h, t;
 	/*
 	 *  what about the packing ?
 	 */
 	} FimgFileHead;
 #define MAGIC_AREA51	0xA5EA0051
 typedef struct {
-	uint32_t	magic;
+	unsigned long	magic;
 	int		w, h;
 	int		x, y;
 	int		flags;
@ -101,8 +50,6 @@ 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
@ -110,7 +57,7 @@ typedef struct {
 #define CONTRAST_POW2			2
 #define CONTRAST_COS01			3
 #define CONTRAST_COS010			4
-#define CONTRAST_XPER			5		/* use with caution */
+
 /*
 *	core module
 */
@ -148,26 +95,20 @@ int fimg_mul_3(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
 /* ---------------------------------------------------- */
 /*	funcs/filtrage.c		*/
 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);
-/* ---------------------------------------------------- */
+int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int reverse);
 /*	 module sfx0.c			*/
 int fimg_killcolors_a(FloatImg *fimg, float fval);
@ -182,33 +123,20 @@ 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);
@ -225,30 +153,16 @@ 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/equalize.c		*/
+/*	module funcs/??????.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);
@ -260,6 +174,7 @@ 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);
@ -268,24 +183,13 @@ int fimg_displacement_0(FloatImg *psrc, FloatImg *pdst, int flags);
 /*	module funcs/rampes.c		*/
 int fimg_hdeg_a(FloatImg *img, double dcoef);
 int fimg_vdeg_a(FloatImg *img, double dcoef);
 int fimg_do_stripes(FloatImg *img, float fmax, int mode);
-/*	FIMG native file module		*/
+/*	FIMG files 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);
@ -294,23 +198,19 @@ 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);
@ -325,17 +225,13 @@ 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]);
--- a/src/funcs/Makefile
+++ b/src/funcs/Makefile
@ -2,28 +2,30 @@
 #		Please, use the 'Gloabl.makefile' system !
 LIB_DIR = ../../build/lib
 OBJ_DIR = ../../build/obj
 STATIC_LIB = $(LIB_DIR)/libfloatimg.a
 DYN_OBJ = $(OBJ_DIR)/libfloatimg-funcs.o
 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 rectangle.o			\
+	fimg-libpnm.o rampes.o sfx0.o sfx1.o sfx2.o sfx4.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	\
-	killrgb.o recurse.o pixelize.o decomprgb.o
+	recurse.o
 all:	$(OBJS) $(STATIC_LIB) $(DYN_OBJ)
 #---------------------------------------------------------------
 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						\
@ -33,29 +35,22 @@ t:	t.c $(DEPS) ../libfloatimg.a tests.o
 		-ltiff						\
 		-lz -lm -o $@
-tpnm:		tpnm.c Makefile fimg-libpnm.o
+tests.o:	tests.c tests.h $(DEPS)
-	gcc $(COPT) -I/usr/include/netpbm 			\
+	gcc $(COPT) -I/usr/include/netpbm -c $<
 		fimg-libpnm.o -lnetpbm  $< -o $@
 #---------------------------------------------------------------
 #	upper-level functions
-../libfloatimg.a:       $(OBJS)
+$(STATIC_LIB):       $(OBJS)
 	$(AR) r $@ $?
 # ###
-rectangle.o:		rectangle.c  $(DEPS)
+$(DYN_OBJ):	$(OBJS)
-	gcc $(COPT) -c $<
+	mkdir -p $(OBJ_DIR)
 	ld -Ur -o $@ $?
-decomprgb.o:		decomprgb.c  $(DEPS)
+clean:
-	gcc $(COPT) -c $<
+	rm -rf $(OBJS) $(STATIC_LIB) $(DYN_OBJ)
 pixelize.o:		pixelize.c  $(DEPS)
 	gcc $(COPT) -c $<
 killrgb.o:		killrgb.c  $(DEPS)
 	gcc $(COPT) -c $<
 recurse.o:		recurse.c  $(DEPS)
 	gcc $(COPT) -c $<
@ -66,9 +61,6 @@ 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 $<
@ -81,9 +73,6 @@ 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 $<
@ -126,9 +115,6 @@ 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 $<
@ -147,11 +133,6 @@ 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 $<
--- a/src/funcs/README.md
+++ b/src/funcs/README.md
@ -0,0 +1,26 @@
 # Fonctions
 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.
 ## Exporter
 Une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
 une image en fonction de l'extension du nom de fichier.
 ## Sfx
 Effets spéciaux divers.
 ## Dithering
 Work in progress...
--- a/src/funcs/alltests.sh
+++ b/src/funcs/alltests.sh
--- a/src/funcs/classif.c
+++ b/src/funcs/classif.c
@ -5,7 +5,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include  <stdint.h>
 #include   <math.h>
 #include "../floatimg.h"
@ -15,7 +14,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 flags)
+int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int notused)
 {
 float		minmax[6], delta[3], baryc[3];
 float		range, dist, rgb[3], dr, dg, db;
@ -26,8 +25,6 @@ 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;
--- a/src/funcs/contour2x2.c
+++ b/src/funcs/contour2x2.c
@ -4,7 +4,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include  <stdint.h>
 #include <string.h>
 #include   <math.h>
--- a/src/funcs/displacement.c
+++ b/src/funcs/displacement.c
@ -4,7 +4,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include  <stdint.h>
 #include <string.h>
 #include   <math.h>
@ -22,6 +21,7 @@ float		minmax[6];
 float		rgb[3];
 float		dltr, dltg, dltb;	/* delta des minmax */
 float		dispx, dispy;
 int		dstx, dsty;
 int		in, out;
@ -39,14 +39,10 @@ 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];
@ -82,7 +78,9 @@ 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);
--- a/src/funcs/dithering.c
+++ b/src/funcs/dithering.c
@ -4,7 +4,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include  <stdint.h>
 #include <string.h>
 #include   <math.h>
@ -17,23 +16,11 @@ 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 */
 		}
 	}
--- a/src/funcs/equalize.c
+++ b/src/funcs/equalize.c
@ -7,54 +7,12 @@
 #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];
@ -73,8 +31,6 @@ 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];
@ -88,7 +44,7 @@ if ( (minmax[0]<0.0) || (minmax[2]<0.0) || (minmax[4]<0.0) ) {
 	return -4;
 	}
-fprintf(stderr, "deltas  %12.4g  %12.4g  %12.4g\n", dr, dg, db);
+// printf("deltas  %12.4g  %12.4g  %12.4g\n", dr, dg, db);
 return 0;
 }
--- a/src/funcs/exporter.c
+++ b/src/funcs/exporter.c
@ -4,7 +4,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <string.h>
 #include "../floatimg.h"
@ -25,8 +24,6 @@ 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);
@ -56,15 +53,9 @@ 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;
--- a/src/funcs/filtrage.c
+++ b/src/funcs/filtrage.c
@ -1,43 +1,11 @@
 /*
 *		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)
 {
@ -59,21 +27,19 @@ if (dst->type != FIMG_TYPE_RGB) {
 	return -99;
 	}
 if (fimg_images_not_compatible(src, dst)) {
-	fprintf(stderr, "%s: src & dst not compatibles\n", __func__);
+	fprintf(stderr, "%s: src & dst not comatibles\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)]	+
@ -140,7 +106,9 @@ 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]	+
@ -155,6 +123,7 @@ for (y=1; y < img->height-1; y++) {
 	pr[offset] = cr / 4.0;
 	pg[offset] = cg / 4.0;
 	pb[offset] = cb / 4.0;
 	}
 }
@ -195,6 +164,7 @@ for (idx=0; idx<h; idx++) {
 	}
 o = w * (h - 1);
 for (idx=0; idx<w; idx++) {
 #if FAST
 	img->R[idx] = 0.0;
@ -216,10 +186,6 @@ 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);
@ -231,54 +197,4 @@ 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;
 }
 /* -------------------------------------------------------------------- */
--- a/src/funcs/fimg-bmp.c
+++ b/src/funcs/fimg-bmp.c
--- a/src/funcs/fimg-fits.c
+++ b/src/funcs/fimg-fits.c
@ -8,8 +8,6 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <stdint.h>
 #include  <sys/time.h>
 #include  <fitsio.h>
@ -32,8 +30,6 @@ 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) {
@ -54,7 +50,7 @@ if (fits_create_file(&fptr, outname, &status)) {
 	}
 naxes[0] = src->width;		naxes[1] = src->height;
-if (verbosity > 1) fimg_describe(src, "to be saved as FITS");
+if (verbosity) fimg_describe(src, "to be saved as FITS");
 if ( fits_create_img(fptr,  bitpix, naxis, naxes, &status) ) {
 	fits_report_error(stderr, status);
--- a/src/funcs/fimg-libpnm.c
+++ b/src/funcs/fimg-libpnm.c
@ -4,7 +4,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include  <stdint.h>
 #include <string.h>
 #include  <pam.h>        
@ -14,16 +13,17 @@
 extern int		verbosity;
 /* --------------------------------------------------------------------- */
-static void print_struct_pam(struct pam *ppam, char *text)
+static void print_struct_pam(struct pam *ppam, char *txt)
 {
 printf("\ttext                %s\n", text);
 printf("\tsize                %d\n", ppam->size);
-printf("\tformat              %d 0x%04x\n", ppam->format, ppam->format);
+printf("    size                %d\n", ppam->size);
-printf("\tplainformat         %d\n",	ppam->plainformat);
+
-printf("\twidth & height      %d %d\n", ppam->width, ppam->height);
+printf("    format              %d\n", ppam->format);
-printf("\tdepth               %d\n", ppam->depth);
+printf("    plainformat         %d\n", ppam->plainformat);
-printf("\tmaxval              %lu\n", ppam->maxval);
+printf("    width & height      %d %d\n", ppam->width, ppam->height);
 printf("    depth               %d\n", ppam->depth);
 printf("    maxval              %lu\n", ppam->maxval);
 }
 /* --------------------------------------------------------------------- */
@ -36,14 +36,13 @@ FILE			*fp;
 fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
 #endif
 printf("    --- infos for '%s' ------------\n", fname);
 if (NULL==(fp=fopen(fname, "r"))) {
 	perror(fname);
 	exit(1);
 	}
 pnm_readpaminit(fp, &inpam, sizeof(inpam));
 print_struct_pam(&inpam, fname);
 fclose(fp);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mutah	28698c4f60	FloatImg sources upgraded to version 150	2021-05-19 21:53:22 +02:00
Mutah	c842ff3f54	FloatImg sources upgraded to version 148	2021-05-16 11:43:46 +02:00
Mutah	f36984db0d	Add v4l tools to build system	2021-05-14 00:23:21 +02:00
Mutah	3dfaff7df4	FloatImg sources upgraded to version 147	2021-05-13 12:32:20 +02:00
John Doe	bbc0309591	source tree refactor and build system (to be completed)	2021-05-11 22:44:13 +02:00