not ready for prime time

README.md

@@ -2,8 +2,8 @@
 
 C'est d"abord un ensemble de fonctions pour traiter des images avec une énorme dynamique
 sur les niveaux de pixels. C'est aussi quelques outils pour traiter ces images.
-Et c'est enfin un embryon de logiciel destiné à faire des photos floues, voire même
-des [films flous](Fonderie/).
+Et c'est enfin plusieurs embryons de logiciel destiné à faire des photos floues,
+voire même des [films flous](Fonderie/).
 
 ![horloge floue](http://la.buvette.org/photos/cumul/horloge.png "horloge floue")
 

doc/the_floatimg_hack.tex

@@ -68,7 +68,7 @@ chaque pixel en virgule flottante sur 32bits, le type
 
 % XXX XXX XXX\vspace{1em}
 
-Attention, tout le code que nous allons voir ensemble est en
+\textbf{Attention !} tout le code que nous allons voir ensemble est en
 perpétuelle évolution\footnote{voir page \pageref{TODO}},
 et sa fiablité (surtout sur certains aspects mathématiques) 
 reste à démontrer\index{valgrind}.
@@ -77,11 +77,57 @@ pour ceux qui suivent le canal \texttt{\#tetalab} sur le réseau
 IRC de Freenode.
 
 \textbf{Attention !} ce document commence par une bonne rafale
-de technique parfois hardue\footnote{gni?}.
+de technique parfois \textsl{hardue}.
 Vous avez parfaitement le droit de sauter directement à
 la page \pageref{outils} pour quelque chose de plus concret.
 
 % -------------------------------------------------------------------
+%
+%  d'après le mail de JearZ, en avril 2021, sur la ml tetalab@
+%
+\subsection*{MiniFaq}\index{FAQ}
+
+En avril 2021, pendant la fin d'un monde, on m'a demandé de préciser
+certains points. Je vais tenter de répondre à ces FAQ~:%
+« Fréquentes et Absurdes Questions » avec des réponses
+absurdes et précises.
+
+\subsubsection*{c'est quoi un image d'un point de vue physique ?}
+
+Une représentation approximative d'un monde physique invisible.
+L'infinie bio-complexité de notre système oculaire et ses interactions
+avec notre multivac neuronal n'est devenue quantifiable qu'avec
+l'arrivée des premiers calculateurs
+numériques quand certains ont songé à passer du flou mental à la grille physique.
+
+\subsubsection*{quelques rappels de comment on acquiert et numérise une image}
+
+Avant de se l'approprier, il vaut la rendre réelle dans sa vision intérieur.
+Il faut l'imaginer comme des lignes de code interposées entre la grille
+physique dont on vient de parler, et une autre grille, bien réelle, des
+pixels sur notre écran Trititron\footnote{Sony, u'r the best !} de 44cm.
+Et puisque on en parle, je me permet de vous conseiller avec
+\textbf{vigueur} la webcam de Playstation (aka PsEye).
+Moins de 10 Euros
+dans les trocs, et un grain d'image vraiment présent.
+
+\texttt{https://fr.wikipedia.org/wiki/PlayStation\_Eye}
+
+\subsubsection*{définir les notions de base: canal, pixel, codage couleurs}
+
+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 pixels, pour concrétiser l'existence perceptuelles de ces
+grains de lumière chromatisés.
+
+\subsubsection*{quelques belles images / schémas polychromes en intro pour 
+			illustrer tout ça}
+
+Tour cela est dans le grand Ternet\footnote{\textsl{bik kudo 2 J Postel}}
+mondial, je pourrais même vous donner l'url si vous me promettez de ne pas
+la glissr dans le capitalisme de surveillance.
+
+% ===================================================================
 
 \setlength \parskip {0em}
 
@@ -142,6 +188,8 @@ la mesure de nos moyens.
 Nous allons donc directement rentrer au cœur du problème,
 en écrivant quelques lignes de code.
 
+\subsection{L'idée}
+
 Pour commencer par quelque chose de simple, 
 nous allons créer une image RGB\index{RGB} complètement noire,
 puis l'enregistrer dans un fichier \texttt{.fimg}\index{.fimg},
@@ -196,6 +244,8 @@ mean values:
 max value       0.000000
 \end{verbatim}
 
+\subsection{Action ?}
+
 Nous avons donc sous la main un ensemble d'outils mécaniques qui ne demande
 qu'à faire des trucs futiles et des images qui clignotent.
 Avec un bon script bash, il y a déja de quoi faire.

experiment/Makefile

@@ -8,10 +8,7 @@ LIBS = -ltiff -lpnglite -lcfitsio
 
 all:	assemblage extracteur
 
-incrustator.o:	incrustator.c incrustator.h Makefile
-	gcc -c $(COPT) $<
-
-assemblage:	assemblage.c Makefile incrustator.o
+assemblage:	assemblage.c Makefile 
 	gcc $(COPT) $< incrustator.o ../libfloatimg.a $(LIBS) -o $@
 
 extracteur:	extracteur.c Makefile 

experiment/extracteur.c

@@ -14,7 +14,7 @@ int		verbosity;
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
 
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-int print_rectangle(Rectangle *rect)
+int print_rectangle(FimgArea51 *rect)
 {
 
 printf("rect @ %p  :  %dx%d  at  %d,%d\n", rect, rect->w, rect->h,
@@ -24,7 +24,7 @@ return 0;
 }
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-int essai_extraction(FloatImg *in, FloatImg *out, Rectangle *rect)
+int essai_extraction(FloatImg *in, FloatImg *out, FimgArea51 *rect)
 {
 int		foo;
 int		xs, ys, xd, yd;
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
 {
 int		foo, opt;
 FloatImg	src, dst;
-Rectangle	zone;
+FimgArea51	zone;
 char		*infile  = "foo.fimg";
 char		*outfile = "out.fimg";
 

experiment/incrustator.h

@@ -2,11 +2,8 @@
  *		incrustator experimental
  */
 
-typedef struct	{
-	unsigned long	magic;
-	int		w, h;
-	int		x, y;
-		} FimgArea51;
-
+/*
+ *		MOVED TO 'funcs/inscrutator.c'
+ */
 int incrustator_0(FloatImg *psrc, FloatImg *pdst,
 				int xpos, int ypos, int flags);

floatimg.h

@@ -4,7 +4,7 @@
  *	http://la.buvette.org/photos/cumul
  */
 
-#define		FIMG_VERSION	137
+#define		FIMG_VERSION	141
 
 /*
  *	in memory descriptor
@@ -33,7 +33,7 @@ typedef struct {
 	int		w, h;
 	int		x, y;
 	int		flags;
-	} Rectangle;
+	} FimgArea51;
 
 #define FIMG_TYPE_GRAY			1
 #define FIMG_TYPE_RGB			3
@@ -164,11 +164,16 @@ int fimg_mk_gray_from(FloatImg *src, FloatImg*dst, int k);
 int fimg_desaturate(FloatImg *src, FloatImg *dst, int notused);
 
 /*	module funcs/geometry.c		*/
+		/* warning, this module is a mess */
 int fimg_halfsize_0(FloatImg *src, FloatImg *dst, int notused);
 int fimg_halfsize_1(FloatImg *src, FloatImg *dst, int notused);
-int fimg_extractor(FloatImg *in, FloatImg *out, Rectangle *rect);
+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);
+
 int fimg_displacement_0(FloatImg *psrc, FloatImg *pdst, int flags);
 
 /*	module funcs/rampes.c		*/
@@ -217,7 +222,7 @@ int   fimg_multirandom(FloatImg *fimg, long nbpass);
 void fimg_print_minmax(float minmax[6], char *titre);
 int parse_WxH(char *str, int *pw, int *ph);
 int parse_double(char *str, double *dptr);
-int parse_rectangle(char *str, Rectangle *r, int notused);
+int parse_rectangle(char *str, FimgArea51 *r, int notused);
 int format_from_extension(char *fname);
 char * extension_from_format(int fmt);
 

funcs/Makefile

@@ -11,7 +11,7 @@ OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o	\
 	geometry.o rotate.o fimg-openexr.o			\
 	equalize.o fimg-fits.o saturation.o histogram.o		\
 	hsv.o classif.o contour2x2.o qsortrgb.o exporter.o	\
-	displacement.o dithering.o plasmas.o
+	displacement.o dithering.o plasmas.o incrustator.o
 
 #---------------------------------------------------------------
 
@@ -33,6 +33,11 @@ tests.o:	tests.c tests.h $(DEPS)
 ../libfloatimg.a:       $(OBJS)
 	$(AR) r $@ $?
 
+# ###
+
+incrustator.o:		incrustator.c  $(DEPS)
+	gcc $(COPT) -c $<
+
 displacement.o:		displacement.c  $(DEPS)
 	gcc $(COPT) -c $<
 

funcs/geometry.c

@@ -105,7 +105,7 @@ for (y=0; y<hd; y++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
-int fimg_extractor(FloatImg *in, FloatImg *out, Rectangle *rect)
+int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect)
 {
 int		foo;
 int		xs, ys, xd, yd;
@@ -136,6 +136,8 @@ for (yd=0; yd<rect->h; yd++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/*    ho, btw, you can have a locck at 'incrustator.c' :)                */
+/* --------------------------------------------------------------------- */
 int fimg_mirror(FloatImg *src, FloatImg *dst, int notused)
 {
 float		*fptr;

funcs/incrustator.c

@@ -1,5 +1,6 @@
 /*
  *		incrustator experimental
+ *						KRKRK
  */
 
 #include  <stdio.h>
@@ -8,7 +9,7 @@
 
 #include  "../floatimg.h"
 
-#include  "incrustator.h"
+// XXX #include  "incrustator.h"
 
 extern int 		verbosity;
 
@@ -43,7 +44,7 @@ fprintf(stderr, ">>> %s ( %p %p %p 0x%04x )\n", __func__,
 return -1;
 }
 /* ---------------------------------------------------------------- */
-int incrustator_0(FloatImg *psrc, FloatImg *pdst,
+int fimg_incrustator_0(FloatImg *psrc, FloatImg *pdst,
 				int xpos, int ypos, int flags)
 {
 int		y, srcpos, dstpos, szl;

funcs/saturation.c

@@ -1,5 +1,5 @@
 /*
- *	FloatImg library from tTh - ugly code inside
+ *	FloatImg library from tTh - really ugly code inside
  */
 
 #include  <stdio.h>
@@ -7,7 +7,7 @@
 #include  "../floatimg.h"
 
 /* -------------------------------------------------------------- */
-/*	global vars from main
+/*	global vars exported from main
  */
 extern	int	verbosity;
 
@@ -28,7 +28,6 @@ if (FIMG_TYPE_RGB != img->type) {
 
 for (y=0; y<img->height; y++) {
 	p = y * img->width;		/* first pixel of the row */
-
 	for (x=0; x<img->width; x++) {
 
 		gr = (img->R[p] + img->G[p] + img->R[p]) / 3.0;
@@ -36,15 +35,12 @@ for (y=0; y<img->height; y++) {
 		img->R[p] = ((gr * mix) + (img->R[p] * (1.0-mix))) / 2.0;
 		img->G[p] = ((gr * mix) + (img->G[p] * (1.0-mix))) / 2.0;
 		img->B[p] = ((gr * mix) + (img->B[p] * (1.0-mix))) / 2.0;
-
 		p++;			/* next pixel in the row */
 		}
-
 	}
 
 return 0;
 }
-
 /* -------------------------------------------------------------- */
 /*
  *	The third parameter was a six value array with min and max
@@ -60,7 +56,6 @@ if (FIMG_TYPE_RGB != s->type) {
 	}
 
 sz = s->width * s->height;
-
 for (idx=0; idx<sz; idx++) {
 	d->R[idx] = s->R[idx] - coefs[0];
 	d->G[idx] = s->G[idx] - coefs[2];
@@ -69,10 +64,10 @@ for (idx=0; idx<sz; idx++) {
 
 return 0;
 }
-
 /* -------------------------------------------------------------- */
 /*
- *    I think that this function is fully buggy
+ *    I think that this function is fully buggy, and need
+ *    more explanations.
  */
 int  fimg_auto_shift_to_zero(FloatImg *src, FloatImg *dst)
 {
@@ -80,6 +75,10 @@ float		coefs[6];
 int		foo;
 float		minima = 1e7;		/* magic value ? */
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
+#endif
+
 if (FIMG_TYPE_RGB != src->type) {
 	fprintf(stderr, "%s: bad image type %d\n", __func__, src->type);
 	return -6;

funcs/utils.c

@@ -75,7 +75,7 @@ return -1;
 /*
  *	/!\	return 4 on success
  */
-int parse_rectangle(char *str, Rectangle *r, int notused)
+int parse_rectangle(char *str, FimgArea51 *r, int notused)
 {
 int		x, y, w, h, foo;
 

tools/fimgfx.c

@@ -22,7 +22,7 @@ typedef struct {
 
 enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
 		Fx_rot90, Fx_cmixa, Fx_desat, Fx_ctr2x2, Fx_norm,
-		Fx_classtrial, Fx_mirror,
+		Fx_classtrial, Fx_mirror, Fx_shift0,
 		Fx_xper, Fx_binarize, Fx_trinarize,Fx_hilight_R };
 
 Fx fx_list[] = {
@@ -38,6 +38,7 @@ Fx fx_list[] = {
 	{ "desat",		Fx_desat,	0,	1 },
 	{ "ctr2x2",		Fx_ctr2x2,	0,	1 },
 	{ "mirror",		Fx_mirror,	0,	1 },
+	{ "shift0",		Fx_shift0,	0,	1 },
 //	{ "norm",		Fx_norm,	0,	1 },
 	{ "classtrial",		Fx_classtrial,	0,	1 },
 	{ "binarize",		Fx_binarize,	0,	1 },
@@ -208,6 +209,10 @@ switch (action) {
 	case Fx_mirror:
 		foo = fimg_mirror(&src, &dest, 0);
 		break;
+	case Fx_shift0:
+		fprintf(stderr, "Krkrk %d\n", action);
+		foo = fimg_auto_shift_to_zero(&src, &dest);
+		break;
 	case Fx_ctr2x2:
 		foo = fimg_contour_2x2(&src, &dest, 0);
 		break;

tools/fimghalfsize.c

@@ -84,7 +84,10 @@ if (verbosity) {
 	}
 
 foo = faire_un_halfsize(srcname, dstname, grayed);
-
+if (foo) {
+	fprintf(stderr, "in %s: make halfsize give a %d\n", argv[0], foo);
+	exit(1);
+	}
 
 return 0;
 }