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 plusieurs embryons de logiciel destiné à faire des photos floues,
-voire même des [films flous](Fonderie/).
+Et c'est enfin un embryon 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}
 
-\textbf{Attention !} tout le code que nous allons voir ensemble est en
+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,57 +77,11 @@ 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 \textsl{hardue}.
+de technique parfois hardue\footnote{gni?}.
 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}
 
@@ -188,8 +142,6 @@ 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},
@@ -244,8 +196,6 @@ 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,7 +8,10 @@ LIBS = -ltiff -lpnglite -lcfitsio
 
 all:	assemblage extracteur
 
-assemblage:	assemblage.c Makefile 
+incrustator.o:	incrustator.c incrustator.h Makefile
+	gcc -c $(COPT) $<
+
+assemblage:	assemblage.c Makefile incrustator.o
 	gcc $(COPT) $< incrustator.o ../libfloatimg.a $(LIBS) -o $@
 
 extracteur:	extracteur.c Makefile 

experiment/extracteur.c

@@ -14,7 +14,7 @@ int		verbosity;
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
 
 /* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
-int print_rectangle(FimgArea51 *rect)
+int print_rectangle(Rectangle *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, FimgArea51 *rect)
+int essai_extraction(FloatImg *in, FloatImg *out, Rectangle *rect)
 {
 int		foo;
 int		xs, ys, xd, yd;
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
 {
 int		foo, opt;
 FloatImg	src, dst;
-FimgArea51	zone;
+Rectangle	zone;
 char		*infile  = "foo.fimg";
 char		*outfile = "out.fimg";
 

experiment/incrustator.c

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

experiment/incrustator.h

@@ -2,8 +2,11 @@
  *		incrustator experimental
  */
 
-/*
- *		MOVED TO 'funcs/inscrutator.c'
- */
+typedef struct	{
+	unsigned long	magic;
+	int		w, h;
+	int		x, y;
+		} FimgArea51;
+
 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	141
+#define		FIMG_VERSION	137
 
 /*
  *	in memory descriptor
@@ -33,7 +33,7 @@ typedef struct {
 	int		w, h;
 	int		x, y;
 	int		flags;
-	} FimgArea51;
+	} Rectangle;
 
 #define FIMG_TYPE_GRAY			1
 #define FIMG_TYPE_RGB			3
@@ -164,16 +164,11 @@ 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, FimgArea51 *rect);
+int fimg_extractor(FloatImg *in, FloatImg *out, Rectangle *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		*/
@@ -222,7 +217,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, FimgArea51 *r, int notused);
+int parse_rectangle(char *str, Rectangle *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 incrustator.o
+	displacement.o dithering.o plasmas.o
 
 #---------------------------------------------------------------
 
@@ -33,12 +33,7 @@ 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)
+displacement.o:	displacement.c  $(DEPS)
 	gcc $(COPT) -c $<
 
 fimg-png.o:		fimg-png.c $(DEPS)

funcs/geometry.c

@@ -105,7 +105,7 @@ for (y=0; y<hd; y++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
-int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect)
+int fimg_extractor(FloatImg *in, FloatImg *out, Rectangle *rect)
 {
 int		foo;
 int		xs, ys, xd, yd;
@@ -136,8 +136,6 @@ 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/saturation.c

@@ -1,5 +1,5 @@
 /*
- *	FloatImg library from tTh - really ugly code inside
+ *	FloatImg library from tTh - ugly code inside
  */
 
 #include  <stdio.h>
@@ -7,7 +7,7 @@
 #include  "../floatimg.h"
 
 /* -------------------------------------------------------------- */
-/*	global vars exported from main
+/*	global vars from main
  */
 extern	int	verbosity;
 
@@ -28,6 +28,7 @@ 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;
@@ -35,12 +36,15 @@ 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
@@ -56,6 +60,7 @@ 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];
@@ -64,10 +69,10 @@ for (idx=0; idx<sz; idx++) {
 
 return 0;
 }
+
 /* -------------------------------------------------------------- */
 /*
- *    I think that this function is fully buggy, and need
- *    more explanations.
+ *    I think that this function is fully buggy
  */
 int  fimg_auto_shift_to_zero(FloatImg *src, FloatImg *dst)
 {
@@ -75,10 +80,6 @@ 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, FimgArea51 *r, int notused)
+int parse_rectangle(char *str, Rectangle *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_shift0,
+		Fx_classtrial, Fx_mirror,
 		Fx_xper, Fx_binarize, Fx_trinarize,Fx_hilight_R };
 
 Fx fx_list[] = {
@@ -38,7 +38,6 @@ 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 },
@@ -209,10 +208,6 @@ 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,10 +84,7 @@ 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;
 }