adding fimg_get_minmax_rgb function

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

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);

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);
 

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;

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;