diff --git a/doc/the_floatimg_hack.tex b/doc/the_floatimg_hack.tex
index dc0dbdb3..550c083a 100644
--- a/doc/the_floatimg_hack.tex
+++ b/doc/the_floatimg_hack.tex
@@ -117,6 +117,14 @@ quelques milliers d'images standard à 256 niveaux, sans trop avoir
 à se soucier des éventuelles pertes de précision. Mais ça demande
 à être confirmé par des esprits supérieurs.
 
+\subsection{Dynamique}\index{dynamique}
+
+Dynamique, précision et macheps.
+
+\subsection{Pixel négatif ?}
+
+Il est très difficle d'imaginer une lumière négative.
+
 % -------------------------------------------------------------------
 
 \section{Premier exemple}\index{exemple}\label{exemple}
@@ -229,7 +237,7 @@ dans un emplacement approprié, par exemple
 
 Le script \texttt{install.sh}, à la racine du projet, est censé
 faciliter un peu la chose. Il prend également en compte la copie
-des divers binaires du dossier \texttt{tools/} (cf. page \pageref{outils})
+des divers binaires du dossier \texttt{tools/} (cf page \pageref{outils})
 dans le répertoire prévu à cet effet : \texttt{/usr/local/bin}.
 
 Il reste enfin quelques exemples d'utilisation des outils de la
@@ -313,6 +321,11 @@ toutes les informations nécessaires pour exploiter au mieux la dynamique
 de notre image dans les étapes ultérieures, puisque la valeur
 maximale théorique est égale à $fval * count$.
 
+La fonction \texttt{fimg\_printhead(FloatImg *h)} affiche
+sommairement le contenu de ce descripteur,
+et \texttt{fimg\_describe(FloatImg *head, char *txt)} propose
+un affichage plus détaillé. Ça aide parfois.
+
 Une bonne partie des fonctions que nous allons voir est indéterministe.
 Ce qui veut dire, en langage de tous les soirs, que ça risque de ne
 pas être la même chose dans l'avenir.
@@ -442,7 +455,7 @@ de contraste, il y a quelques explication en page \pageref{exemplefunc}.
 \end{figure}
 
 Rappelons qu'il est possible pour un logiciel applicatif
-comme \texttt{grabvidseq} (Cf page \pageref{grabvidseq})
+comme \texttt{grabvidseq} (cf page \pageref{grabvidseq})
 de renseigner deux champs du descripteur d'image avec des
 données pertinentes.
 Ces deux champs sont \textit{fval} et \textit{count}.
@@ -462,9 +475,12 @@ festive qu'il manquait des données dans la chaine de traitement.
 L'autre façon de procéder est d'explorer notre image à la
 recherche de la valeur maximale.
 La fonction \texttt{float fimg\_get\_maxvalue(\&fimg)} est
-faite pour ça.
+prévue pour ça de façon sommaire.
 C'est actuellement la méthode utilisée par l'outil qui
 sert à faire les modifications de contraste (page \pageref{fimgfx}).
+On pourra aussi envisager d'utiliser 
+\texttt{fimg\_get\_minmax\_rgb(FloatImg *head, float mmvals[6])},
+qui permet un contrôle bien plus fin des dérives.
 
 La prochaine étape consistera à trouver une façon de faire
 une égalisation\index{égalisation} par histogramme\index{histogramme}
@@ -477,7 +493,7 @@ de pixel flottant.
 
 Très prochainement, le retour du blitter\index{blitter}.
 Et pour attendre, un truc improbable, voire même
-inutile.
+inutile, en fait l'inverse de l'upscaling.
 
 \begin{lstlisting}
 /*	module funcs/geometry.c		*/
@@ -1070,10 +1086,11 @@ v4l2.
 
 \subsection{grabvidseq}\index{grabvidseq}\label{grabvidseq}
 
-Un logiciel en évolution, qui permet déja la capture d'images en
+Un logiciel en évolution (trop ?) lente, qui permet déja la capture
+d'images en
 \textsl{longue pose} selon la méthode du cumul\index{cumul}, et
 devrait bientôt retrouver sa capacité à enregistrer des
-séquences.
+séquences d'images.
 
 \begin{verbatim}
 tth@debian:~/Devel/FloatImg/v4l2$ ./grabvidseq -h
diff --git a/floatimg.h b/floatimg.h
index 7bb505ed..e6d6b5c7 100644
--- a/floatimg.h
+++ b/floatimg.h
@@ -127,8 +127,9 @@ int   fimg_dump_to_file(FloatImg *head, char *fname, int notused);
 int   fimg_load_from_dump(char *fname, FloatImg *where);
 int   fimg_create_from_dump(char *fname, FloatImg *head);
 
-/*	mathematics operations */
+/*	mathematics operations 				*/
 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);
 void  fimg_add_cste(FloatImg *fi, float value);
diff --git a/funcs/t.c b/funcs/t.c
index 5e0346ad..aff4abb6 100644
--- a/funcs/t.c
+++ b/funcs/t.c
@@ -54,13 +54,21 @@ else	{
 
 foo = fimg_clone(&src, &dst, 0);
 
+fimg_filter_3x3(&src, &dst, &filter_a);
+foo = fimg_clamp_negativ(&dst);
+if (foo) {
+	fprintf(stderr, "clamped %d negative pixels\n", foo);
+	}
+foo = fimg_save_as_png(&dst, "f3x3a.png", 0);
+// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);
+
 fimg_filter_3x3(&src, &dst, &filter_b);
 foo = fimg_clamp_negativ(&dst);
 if (foo) {
-	fprintf(stderr, "clamped %d negativ pixels\n", foo);
+	fprintf(stderr, "clamped %d negative pixels\n", foo);
 	}
-foo = fimg_save_as_png(&dst, "f3x3.png", 0);
-foo = fimg_save_as_pnm(&dst, "f3x3.pnm", 0);
+foo = fimg_save_as_png(&dst, "f3x3b.png", 0);
+// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);
 
 fimg_destroy(&src);	fimg_destroy(&dst);
 
diff --git a/lib/fimg-math.c b/lib/fimg-math.c
index bfcd23ea..0c4e3984 100644
--- a/lib/fimg-math.c
+++ b/lib/fimg-math.c
@@ -8,6 +8,7 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <string.h>
+#include  <float.h>		/* for FLT_MAX */
 #include  <math.h>
 
 #include  "../floatimg.h"
@@ -44,6 +45,45 @@ switch (head->type) {
 return maxval;
 }
 /* ---------------------------------------------------------------- */
+/*
+ *	mmval[0] <- min(R)    mmval[1] <- max(R)
+ */
+int fimg_get_minmax_rgb(FloatImg *head, float mmvals[6])
+{
+int		idx, surface;
+float		fval;
+
+if (head->type != FIMG_TYPE_RGB) {
+	fprintf(stderr, "%s : type %d invalide\n",
+				__func__, head->type);
+	return -2;
+	}
+
+surface = head->width * head->height;
+mmvals[0] = FLT_MAX;	mmvals[1] = -FLT_MAX;
+mmvals[2] = FLT_MAX;	mmvals[3] = -FLT_MAX;
+mmvals[4] = FLT_MAX;	mmvals[5] = -FLT_MAX;
+
+for (idx=0; idx<surface; idx++) {
+	fval = head->R[idx];
+	if      (fval < mmvals[0])	mmvals[0] = fval;
+	else if (fval > mmvals[1])	mmvals[1] = fval;
+	fval = head->G[idx];
+	if      (fval < mmvals[2])	mmvals[2] = fval;
+	else if (fval > mmvals[3])	mmvals[3] = fval;
+	fval = head->B[idx];
+	if      (fval < mmvals[4])	mmvals[4] = fval;
+	else if (fval > mmvals[5])	mmvals[5] = fval;
+	}
+#if 0
+for (foo=0; foo<6; foo++) {
+	fprintf(stderr, "%3d    %g\n", foo, mmvals[foo]);
+	}
+#endif
+
+return -0;
+}
+/* ---------------------------------------------------------------- */
 int fimg_meanvalues(FloatImg *head, float means[4])
 {
 int		idx, surface;
diff --git a/lib/t.c b/lib/t.c
index 72bf73a2..f2fe1679 100644
--- a/lib/t.c
+++ b/lib/t.c
@@ -55,7 +55,7 @@ int essai_interpolate(int k)
 FloatImg	A, B, C;
 int		foo, idx;
 char		ligne[200];
-float		fval;
+float		fval, minmax[6];
 
 foo = fimg_create(&A, WI, HI, FIMG_TYPE_RGB);
 if (foo) {
@@ -176,6 +176,29 @@ return 0;
 
 #undef TAILLE
 
+/* ---------------------------------------------------------------- */
+int essai_get_values(char *fname)
+{
+int		foo;
+FloatImg 	dessin;
+float		vals[6];
+
+foo = fimg_create_from_dump(fname, &dessin);
+if (foo) {
+	fprintf(stderr, "in %s, error %d loading '%s'\n",
+			__func__,	foo, fname);
+	return foo;
+	}
+
+fimg_get_minmax_rgb(&dessin, vals);
+
+for (foo=0; foo<6; foo++) {
+	fprintf(stderr, "%7d    %17.6g\n", foo, vals[foo]);
+	}
+
+
+return -1;
+}
 /* ---------------------------------------------------------------- */
 
 int essai_contraste(char *fname)
@@ -250,7 +273,7 @@ if (verbosity) fimg_print_version(0);
 // foo = essai_clone_et_copy(0);
 // fprintf(stderr, "retour essai clone'n'copy -> %d\n", foo);
 
-foo = essai_interpolate(0);
+foo = essai_get_values("quux.fimg");
 fprintf(stderr, "retour essai interpolate -> %d\n", foo);
 
 return 0;