add a remember

Fonderie/interpolator.c

@@ -58,6 +58,10 @@ fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, ptr_glob,
 				ptr_idxval, method);
 #endif
 
+if (0 == method) {
+	fprintf(stderr, "\tWTF? in %s, method was ZERO?\n", __func__);
+	}
+
 nombre = ptr_glob->gl_pathc;
 
 /* allocate the array for the sorting action */
@@ -66,7 +70,7 @@ if (NULL==idxvalues) {
 	fprintf(stderr, "MEMORY ERROR in %s\n", __func__);
 	exit(1);
 	}
-fprintf(stderr, "IdxValues array at %p\n", idxvalues);
+// fprintf(stderr, "IdxValues array at %p\n", idxvalues);
 
 *ptr_idxval = idxvalues;
 average     = 0.0;
@@ -104,7 +108,7 @@ if (verbosity > 1) {
 average /= (double)nombre;
 *p_average = average;
 
-fprintf(stderr, "\naverage %f\n", average);
+fprintf(stderr, "\naverage of ??? is %f\n", average);
 
 return 0;
 }
@@ -133,7 +137,7 @@ if (negative) fprintf(stderr, "%s: negative ON\n", __func__);
 
 memset(&globbuf, 0, sizeof(glob_t));
 foo = glob(pattern, 0, NULL, &globbuf);
-fprintf(stderr, "globbing '%s' -> %d, %d files found\n",
+fprintf(stderr, "    globbing '%s' -> %d, %d files found\n",
 			pattern, foo, (int)globbuf.gl_pathc);
 if (0 == globbuf.gl_pathc) {
 	fprintf(stderr, "%s : no file found, aborting\n", __func__);
@@ -253,7 +257,7 @@ int		sort = 0;
 char		*InFchain  = "0";
 char		*OutFchain = "0";
 
-fprintf(stderr, "*** %s : compiled by tTh, %s %s\n", __FILE__,
+fprintf(stderr, "*** %s\n\tcompiled by tTh, %s %s\n", argv[0],
 			__DATE__, __TIME__);
 fimg_print_version(2);
 
@@ -303,6 +307,7 @@ if (verbosity) {
 	fprintf(stderr, "\toutput dir        '%s'\n", argv[optind+1]);
 	fprintf(stderr, "\tsrc filter        '%s'\n", InFchain);
 	fprintf(stderr, "\tout filter        '%s'\n", OutFchain);
+	fprintf(stderr, "\tsort               %d\n", sort);
 	}
 
 if (verbosity > 1) {

Fonderie/singlepass.c

@@ -25,6 +25,9 @@
 int		verbosity;
 
 /* ----------------------------------------------------------- */
+/*
+ *	parameter 'duplic' is the repetition factor
+ */
 int run_the_singlepass(char *globber, char *destdir, int duplic,
 					int fchain, int outfmt)
 {
@@ -35,8 +38,8 @@ char		*fname;
 double		elapsed;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' '%s' %d %d )\n", __func__,
+fprintf(stderr, ">>> %s ( '%s' '%s'  %d  %d %d )\n", __func__,
-				globber, destdir, fchain, outfmt);
+				globber, destdir, duplic, fchain, outfmt);
 #endif
 
 if (verbosity) filterstack_list(fchain, "Run the single pass");
@@ -107,14 +110,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);
-			}
 		}
 	}
 
-fprintf(stderr, "\n");
+fprintf(stderr, "\n\n");
 
 globfree(&globbuf);
 
@@ -156,7 +155,7 @@ char		*outdir      =   "./p8";
 int		do_xper = 0;
 int		repeat = 1;
 
-fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
+fprintf(stderr, "*** %s\n\tcompiled %s %s\n", argv[0],
                         __DATE__, __TIME__);
 fimg_print_version(2);
 
@@ -212,6 +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, "\n\tRun the single pass --> %d\n", foo);

build.sh

@@ -4,7 +4,7 @@
 
 function build
 {
-echo ============= $1 ==============
+echo "============= $1 =============="
 curdir=${PWD}
 cd $1
 make 
@@ -13,7 +13,7 @@ cd ${curdir}
 
 if [ ${error} -ne 0 ]
 then
-	echo === error on $1 = ${error}
+	echo "=== error on $1 = ${error}"
 	exit 1
 fi
 }
@@ -28,7 +28,7 @@ build Fonderie
 
 # ------------------------------------------------------------------
 
-
+echo "========== Project root ==============="
 make
 
 # ------------------------------------------------------------------

doc/the_floatimg_hack.tex

@@ -124,7 +124,7 @@ dans les machin-trocs, et un grain d'image vraiment présent.
 
 Ah vous en voulez de la technique ? Oké, on y va.
 En fait, on va tripoter pleins de nombres, plus ou moins rangés dans
-des champs de pixels, pour concrétiser l'existence perceptuelles de ces
+des champs de pixels, pour concrétiser l'existence perceptuelle de ces
 grains de lumière chromatisés.
 
 \subsubsection*{quelques belles images / schémas polychromes en intro pour 
@@ -145,8 +145,8 @@ la glisser dans le capitalisme de surveillance.
 % XXX \layout \pagebreak
 
 % ===================================================================
-\section{Théorie}\index{théorie}
 
+\section{Théorie}\index{théorie}
 
 Pour le moment, seule la quête de l'empirisme absolu a été
 visée. Les justifications mathématiques attendront le retour
@@ -659,8 +659,9 @@ aux bonnes dimensions (échange W et H).
 \subsection{Format du fichier \textsc{fimg}}\index{format}\label{formatfimg}
 
 D'un design très empirique, c'est certainement à revoir pour l'avenir.
-Tout d'abord pour normaliser l'endianess et le packing dans les structs%
+La force du \textsl{legacy} va-t-elle dominer le monde ?
-\footnote{Ce qui n'est pas encore fait}, et surtout l'ajout
+Il faudrait normaliser l'endianess et le packing dans les structs%
+\footnote{Directives du compilateur ?}, et surtout l'ajout
 de données sur la prise de vue, du genre type de capteur, date et heure,
 réglages divers\dots
 
@@ -673,14 +674,22 @@ typedef struct {
 
 
 Le champ \texttt{magic[8]} doit contenir une valeur magique~:
-les quatre premier octets doivent contenir les quatre caractères
+les quatre premiers octets doivent contenir les quatre caractères
-\texttt{'FIMG'}, et les quatre dernier doivent être à 0, sauf que,
+\texttt{'FIMG'}, et les quatre derniers doivent être à 0, sauf que,
-voir plus bas.
+voir plus bas, le cinquième vas vous étonner.
 Le champ \texttt{t} (le type de l'image) doit avoir les trois octets
-de poids fort à 0. Vous trouverez les constantes de type dans le
+de poids fort à 0\footnote{Pourquoi ? Je n'en sais rien.}.
+
+Ensuite, nous aurons (dans le cas courant) : 1, 2 ou 4 blocs
+de WxH pixels sous forme de Float32. La première ligne lue
+est la ligne du haut de l'image. Les valeurs négatives sont
+tolérées.
+
+Vous trouverez les constantes de type pertinentes dans le
 fichier \texttt{floatimg.h}, et quelques informations
 (non-)essentielles qui ne vous serviront probablement à rien.
 
+
 %		----------------------------------
 % new février 2022
 
@@ -1714,16 +1723,43 @@ Par exemple pour choisir une image sur dix, le glob-pattern sera
 dans le manuel~: \texttt{glob(7)}, et \texttt{glob(3)} pour la
 fonction utilisée.
 
+% -------------------------------------------------------------------
+
 \subsection{Interpolator}\index{interpolator}
 
-Juste des calculs pas si simple que ça. Je pense qu'il faut
+Pour le moment, juste des calculs pas si simple que ça.
+Je pense qu'il faudra
 se lancer dans des calculs splinesques pour améliorer les choses dans
 la création des images intermédiaires.
+Voyons d'abord le principe actuel.
+
+Nous avons une série de centaines, voire de milliers de photos.
+En parcourant cette liste, nous allons en prélever une sur $N$,
+et entre celle-ci et la
+précédente prélevée, nous allons calculer par interpolation
+\textbf{linéaire} $N - 1$ images intermédiaires, et les
+intercaler entre nos deux sélections pour générer le
+flux de sortie.
+
+\begin{verbatim}
+usage:
+        interpolator [options] <inglob> <outdir> <nbsteep>
+options:
+        -E i:bla:k      input  filter chain
+        -F name:j       output filter chain
+        -n              make negative
+        -S nn           mysterious sort
+        -L              list available filters
+        -v              increase verbosity
+\end{verbatim}
+
+% -------------------------------------------------------------------
+
 
 \subsection{Singlepass}
 
 Ce programme \texttt{singlepass} prétend vous permettre de tester
-tous les filtres disponibles, dont on peut avoir la liste
+tous les filtres disponibles, et dont on peut avoir la liste
 avec l'option \texttt{-L}\footnote{liste hélas peu machinable.}
 
 \begin{verbatim}
@@ -1740,9 +1776,11 @@ Il n'y a pas de moyenne mobile, pas d'interpolation, mais un facteur de
 répétition qui permet de dupliquer $N$ fois une image dans le flux de
 sortie. Si bous globez \texttt{frames/????[02468]}, vous prenez
 une image sur deux, alors un facteur de répétition à $2$ conservera
-la 'vitesse' de la séquence, mais avec une petite sacade régulière
+la 'vitesse' de la séquence, mais avec une petite saccade régulière
 de bon aloi \textit{:)}
 
+% -------------------------------------------------------------------
+
 \subsection{Déviance}
 
 Là, nous tombons dans de la \textsl{troiD}\index{3d} de haut niveau,
@@ -1753,6 +1791,21 @@ mais il y aura du zbuffer dedans.
 
 % ===================================================================
 
+\section{Expérimentations} \index{experimental}
+
+Il m'arrive parfois d'avoir de vagues idées d'image, et donc de logiciel,
+qui tournent dans un coin de la tête.
+Parfois je songe à une fonction qui me
+serait bien utile, mais j'ai des doutes sur son 
+\textsc{api}\footnote{Application Programming Interface}\index{api}
+qui soit  à la fois simple et complète. Je fais donc des essais.
+Parfois j'imagine confusément un algorithme\index{algorithme} tordu
+et sans but précis. Je le \textit{runne} et je le \textit{re-runne}
+un gazillion de fois dans mon cerveau processique.
+Quel va être son facteur $O$ ? Je fais donc des essais.
+
+% ===================================================================
+
 \section{Et pour la suite ?}
 
 En fait, je fait de la photo par la méthode du « cumul »\index{cumul}

experiment/extracteur.c

@@ -84,12 +84,12 @@ if (3 != argc-optind) {
 	}
 
 if (verbosity) {
-	fprintf(stderr, "*** %s   %s %s\n", argv[0], __DATE__, __TIME__);
+	fprintf(stderr, "*** %s\n\t%s %s\n", argv[0], __DATE__, __TIME__);
 	fimg_print_version(1);
 	}
 
 infile = argv[optind];	outfile = argv[optind+2];
-fprintf(stderr, "%s   %s -> %s\n", argv[0], infile, outfile);
+fprintf(stderr, "%s\n\t%s  -->  %s\n", argv[0], infile, outfile);
 
 foo = fimg_create_from_dump(infile, &src);
 if (foo) {

experiment/mnt.c

@@ -20,7 +20,6 @@ int calcul_histo_gray(FloatImg *img, char *fname, int nbslots, float *pmax)
 int		offset, nbpix, ival;
 FILE		*fp;
 float		pixel, minp, maxp;
-
 int		*counts;
 
 #if DEBUG_LEVEL
@@ -29,6 +28,7 @@ fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__,
 #endif
 
 if (FIMG_TYPE_GRAY != img->type) {
+	fprintf(stderr, "%s: image is not in greylevel\n", __func__);
 	return -2;
 	}
 
@@ -64,7 +64,7 @@ if (NULL == (fp = fopen(fname, "w"))) {
 	exit(1);
 	}
 for (ival=0; ival<nbslots; ival++) {
-	fprintf(fp, "%6d  %6d\n", ival, counts[ival]);
+	fprintf(fp, "%6d  %8d\n", ival, counts[ival]);
 	}
 fclose(fp);
 
@@ -90,6 +90,15 @@ float		pente, minp, maxp, seuil;
 fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
 #endif
 
+/*
+ *	trying some preprocessor filters
+ */
+//foo = fimg_lissage_2x2(src);
+foo = fimg_lissage_3x3(src);
+if (foo) fprintf(stderr, "    lissage -> %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
@@ -122,8 +131,8 @@ if (foo) fprintf(stderr, "<<< calcul histo -> %d\n", foo);
 
 
 minp = 1e10;
-seuil = 0.640 * maxp;
+seuil = 0.700 * maxp;
-fprintf(stderr, "seuil = %f\n", seuil);
+fprintf(stderr, "    seuil = %f\n", seuil);
 
 for (offset=0; offset<(src->width*src->height); offset++) {
 	pente = tmp.R[offset];
@@ -132,7 +141,7 @@ for (offset=0; offset<(src->width*src->height); offset++) {
 		}
 	if (pente > maxp)		maxp = pente;
 	}
-fprintf(stderr, "minp --> %f      maxp --> %f\n", minp, maxp);
+// fprintf(stderr, "    minp = %f      maxp = %f\n", minp, maxp);
 
 /* recopie dans l'image destination avec translation hauteur */
 for (offset=0; offset<(src->width*src->height); offset++) {
@@ -143,6 +152,9 @@ for (offset=0; offset<(src->width*src->height); offset++) {
 	dst->B[offset] = pente;
 	}
 
+foo = fimg_killborders(dst);
+if (foo) fprintf(stderr, "    killborder -> %d\n", foo);
+
 /* clean the memory */
 fimg_destroy(&tmp);
 

floatimg.h

@@ -20,7 +20,7 @@
  *	https://git.tetalab.org/tTh/FloatImg
  */
 
-#define		FIMG_VERSION	(223)
+#define		FIMG_VERSION	(224)
 #define		RELEASE_NAME	("noname")
 
 /* XXX add a test for stdint.h / uint32_t XXX */
@@ -153,6 +153,7 @@ typedef struct {
  */
 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);
 

funcs/filtrage.c

@@ -200,7 +200,6 @@ for (idx=0; idx<h; idx++) {
 	}
 
 o = w * (h - 1);
-
 for (idx=0; idx<w; idx++) {
 #if FAST
 	img->R[idx] = 0.0;
@@ -233,4 +232,42 @@ fimg_killborders(img);
 return foo;
 }
 /* -------------------------------------------------------------------- */
+/* -------------------------------------------------------------------- */
+int fimg_lissage_3x3(FloatImg *img)
+{
+int		foo;
+FloatImg	tmp;
+
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+
+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_destroy(&tmp);
+if (foo) {
+	fprintf(stderr, "%s: destroy -> %d\n", __func__, foo);
+	abort();
+	}
+
+fimg_killborders(img);
+
+return 0;
+}
+/* -------------------------------------------------------------------- */
 

lib/interpolate.c

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