doc/the_floatimg_hack.tex

@@ -21,10 +21,6 @@
 \usepackage[verbose]{layout}
 
 \makeindex
-
-% ------ a few new commands
-\newcommand{\interparagraphe { \vspace{60pt} } }
-
 % -------------------------------------------------------------------
 \title{Floating images processing}
 \author{tTh}
@@ -35,7 +31,6 @@
 \section{Image flottante ?}
 
 Mais de quoi parle-t-on exactement ?
-
 \vspace{1em}
 
 Traditionnellement, les valeurs des pixels dans les images
@@ -46,15 +41,11 @@ composante, mais c'est loin d'être le cas général.
 J'ai donc souhaité aller plus loin, et coder chaque canal de
 chaque pixel en virgule flottante sur 32bits, le type
 \texttt{float}\index{float} du langage C.
-
 \vspace{1em}
 
 Attention, tout le code que nous allons voir ensemble est en
 perpétuelle évolution\footnote{voir page \pageref{TODO}},
 et sa fiablité reste à démontrer\index{valgrind}.
-Mais le service après-vente est assez réactif. Du moins
-pour ceux qui suivent \texttt{\#tetalab} sur le réseau
-IRC de Freenode.
 
 % -------------------------------------------------------------------
 
@@ -66,9 +57,7 @@ IRC de Freenode.
 
 \textsc{FloatImg} a débuté sous la forme de quelques fonctions
 basiques en C, gérant la structure des données d'image en mémoire
-et sur disque. Ça a été imaginé de façon presque empirique,
-mais nous sommes tous là pour améliorer les choses, dans
-la mesure de nos moyes.
+et sur disque.
 Nous allons donc directement rentrer au cœur du problème.
 
 \vspace{1em}
@@ -134,7 +123,7 @@ La suite vers la page \pageref{codaz}.
 Vous trouverez dans le répertoire \texttt{tools/}\index{tools/}
 d'autres exemples de mise en œuvre des fonctions disponibles
 sous formes d'outils en ligne de commande,
-lesquels sont décrits en page \pageref{outils}.
+décrits en page \pageref{outils}.
 
 % -------------------------------------------------------------------
 \section{Installation}
@@ -145,13 +134,8 @@ Vous devez, en dehors des outils classiques (bash, gcc, make\dots),
 avoir quelques bibliothèques installées\footnote{Les \texttt{-dev}
 pour Debain et dérivées}~: libv4l2, libpnglite, libtiff, libpnm,
 et probablement d'autres choses.
-
-\vspace{1em}
-
-Il est même quasiment certain que Bash soit indispensable, tout
-comme \textsc{gnu}/make\index{make}.
-Une connaissance de base de l'utilisation du shell\index{shell}
-et de l'écriture de Makefile's sera un plus.
+Être familier avec l'utilisation du shell\index{shell} et l'écriture
+de Makefile's sera un plus.
 
 \subsection{Compilation}
 
@@ -161,7 +145,6 @@ de faire un Makefile récursif, mais\dots}.
 Dans chacun des
 répertoires à traiter, ce script devrait trouver un Makefile et un fichier
 \texttt{t.c} source de la cible par défaut du make.
-
 \vspace{1em}
 
 Pour le moment, la procédure d'installation est un peu rude,
@@ -172,8 +155,6 @@ dans un emplacement
 approprié, par exemple
 \texttt{/usr/local/include} et \texttt{/usr/local/lib}.
 
-
-
 % -------------------------------------------------------------------
 \section{Utilisation coté codeur}\label{codaz}
 
@@ -406,7 +387,6 @@ options:
 
 Pour des operateurs paramétrable (comme \texttt{mix}), le paramêtre flottant doit
 être fourni en utilisant l'option \texttt{-k}.
-La véracité mathématique n'est pas garantie.
 
 \subsection{fimg2png, fimg2pnm, fimg2tiff}
 		\index{fimg2png}\label{fimg2png}
@@ -415,11 +395,7 @@ La véracité mathématique n'est pas garantie.
 
 Quelques petits proggies pour exporter notre format\index{.fimg} secret
 vers des choses plus directement utilisables. À condition que le
-code soit écrit et documenté. Peut-être en page \pageref{funcs}\dots
-
-D'un autre coté, écrire un greffon d'import/export pour
-Gimp\index{Gimp}  ou Imagemagick\index{Imagemagick}
-ne devrait pas être trop difficile. Des volontaires ?
+code soit écrit et documenté en page \pageref{funcs}.
 
 \subsection{fimg2gray}\index{fimg2gray}\label{fimg2gray}
 
@@ -450,39 +426,25 @@ Il reste plein de choses à faire pour que ce soit vraiment utilisable.
 % -------------------------------------------------------------------
 \section{Exemples pour yusers}\index{example}
 
-Nous allons \textsl{essayer d'improviser} un exemple presque réel,
-avec un peu de rache\index{rache} dedans.
-
-\vspace{1em}
-
-Nous savons générer une image contenant des pixels aux valeurs
-probablement aléatoires (drand48\index{drand48}). Que se passe-t-il si 
-nous faisons la somme de plusieurs centaines\footnote{Des erreurs toxiques ?}
-de ces images ?
-
 \begin{verbatim}
 #!/bin/bash
 
 ACCU="quux.fimg"
 TMPF="tmp.fimg"
-DIMS="320 240"
+DIMS="640 480"
 
-mkfimg $ACCU $DIMS
+mkfimg ${ACCU} ${DIMS}
 
-for i in {0..1000}
+for i in {0..100}
 do
+        fname=$( printf "f%04d.pnm" $i )
+        echo $fname
         mkfimg -t drand48 ${TMPF} ${DIMS}
-        fname=$( printf "xx%04d.pnm" $i )
-        fimgops $ACCU $TMPF add $ACCU
-        fimg2pnm -v -g $ACCU $fname
 done
-
-convert -delay 10 xx*.pnm foo.gif
 \end{verbatim}
 
-Voilà, si les choses se passent mal, vous allez découvrir
-que votre drand n'est pas si drand que ça.
-
+En fait, je n'ai pas la moindre idée de ce que peut bien
+faire ce code\dots
 
 % -------------------------------------------------------------------
 \section{Video for Linux}\index{v4l2}
@@ -500,10 +462,8 @@ v4l2.
 
 \subsection{grabvidseq}\index{grabvidseq}\label{grabvidseq}
 
-Un logiciel en évolution, 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.
+Un logiciel en devenir, qui permet déja la capture d'images en
+\textsl{longue pose} selon la méthode du cumul\index{cumul}.
 
 \begin{verbatim}
 tth@debian:~/Devel/FloatImg/v4l2$ ./grabvidseq -h
@@ -517,22 +477,13 @@ options :
         -s WxH          size of capture
         -u              try upscaling...
         -v              increase verbosity
-        -X arg          Xperiment option
 \end{verbatim}
 
 La plupart de ces options ont un usage quasi-évident.
 L'option \texttt{-s} doit correspondre à une des
 résolutions possibles de votre capteur. Le type du
 fichier en sortie (option \texttt{-o}) est déterminé par
-l'extension, actuellement 
-seulement \texttt{.fimg} et \texttt{.pnm} sont reconnus.
-La conversion en gris (option \texttt{-g}) mérite un
-peu plus de travail, et une paramétrisation plus facile.
-
-L'option \texttt{-X} me permet d'intégrer des \textit{fritures}
-expérimentales dans le binaire, et ne doit donc pas être
-utilisée dans des scripts si on a des visions à long
-terme.
+l'extension.
 
 \subsubsection{Upscaling}\index{upscaling}\label{upscaling}
 
@@ -542,16 +493,7 @@ de l'image, en profitant du fait que l'on est capable
 de prendre $N$ images en rafale.
 
 Pour être rigoureux dans la prise de vue, ce $N$ doit
-être un multiple de 4, surtout si le nombre de capture est faible..
-
-\vspace{1em}
-
-\textbf{Là, il manque un schéma\dots}
-
-\subsubsection{shoot.sh}\index{shoot.sh}\label{shoot.sh}
-
-\hspace{4cm}XXX\index{XXX}
-
+être un multiple de 4.
 
 \subsection{video-infos}\index{video-infos}\label{video-infos}
 
@@ -562,16 +504,12 @@ Quelles sont ses possibilités de réglage ?
 tth@debian:~/Devel/FloatImg$ v4l2/video-infos -h
 Options :
         -d              select the video device
-        -K nnn          set the K parameter
+        -K              set the K parameter
         -l              list video devices
         -T bla          add a title
         -v              increase verbosity
 \end{verbatim}
 
-Je me sois d'avouer qu'il reste quelques points mystérieux dans
-l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
-ce logiciel doit être pris avec des pincettes. En particulier
-la liste des résolutions disponibles.
 
 % -------------------------------------------------------------------
 \section{Et pour la suite ?}

lib/Makefile

@@ -5,7 +5,7 @@
 COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
 OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o	\
 	fimg-timers.o operators.o fimg-2gray.o		\
-	interpolate.o fimg-compare.o contrast.o
+	interpolate.o fimg-compare.o
 
 DEPS = Makefile ../floatimg.h
 
@@ -34,9 +34,6 @@ fimg-2gray.o:	fimg-2gray.c $(DEPS)
 operators.o:	operators.c $(DEPS)
 	gcc $(COPT) -c $<
 
-contrast.o:	contrast.c $(DEPS)
-	gcc $(COPT) -c $<
-
 interpolate.o:	interpolate.c $(DEPS)
 	gcc $(COPT) -c $<
 

lib/contrast.c

@@ -1,64 +0,0 @@
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <unistd.h>
-#include  <string.h>
-#include  <math.h>
-
-#include  "../floatimg.h"
-
-extern int		verbosity;
-
-/* ---------------------------------------------------------------- */
-int fimg_square_root(FloatImg *s, FloatImg *d, double maxval)
-{
-int		nbre, idx;
-double		dval;
-
-if (s->type != FIMG_TYPE_RGB) {
-	fprintf(stderr, "%s : type %d invalide\n",
-				__func__, s->type);
-	return -4;
-	}
-
-if (NULL==d) {
-	d = s;
-	}
-
-
-nbre = s->width * s->height * 3;
-
-for (idx=0; idx<nbre; idx++) {
-	dval = s->R[idx] / maxval;
-	d->R[idx] = maxval * sqrt(dval);
-	}
-
-return -1;
-}
-/* ---------------------------------------------------------------- */
-int fimg_power_2(FloatImg *s, FloatImg *d, double maxval)
-{
-int		nbre, idx;
-double		dval;
-
-if (s->type != FIMG_TYPE_RGB) {
-	fprintf(stderr, "%s : type %d invalide\n",
-				__func__, s->type);
-	return -4;
-	}
-
-if (NULL==d) {
-	d = s;
-	}
-
-
-nbre = s->width * s->height * 3;
-
-for (idx=0; idx<nbre; idx++) {
-	dval = s->R[idx] / maxval;
-	d->R[idx] = maxval * dval * dval;
-	}
-
-return -1;
-}
-
-/* ---------------------------------------------------------------- */

lib/t.c

@@ -67,53 +67,71 @@ fimg_destroy(&gray);
 return 0;
 }
 /* ---------------------------------------------------------------- */
-
-int fimg_square_root(FloatImg *s, FloatImg *d, double maxval);
-int fimg_power_2(FloatImg *s, FloatImg *d, double maxval);
-
-int essai_contraste(char *fname)
-{
-int		foo;
-FloatImg 	dessin;
-double		maxi;
-
-foo = fimg_create_from_dump(fname, &dessin);
-
-maxi = (double)fimg_get_maxvalue(&dessin);
-fprintf(stderr, "avant    valeur maxi = %f\n", maxi);
-
-fimg_power_2(&dessin, NULL, maxi);
-
-maxi = (double)fimg_get_maxvalue(&dessin);
-fprintf(stderr, "apres    valeur maxi = %f\n", maxi);
-
-fimg_dump_to_file(&dessin, "dst.fimg", 0);
-
-fimg_destroy(&dessin);
-
-return -1;
-}
+/****
+foo = fimg_create(&dessin, W, H, 3);
+petit_dessin(&dessin);
+foo = fimg_create(&noise, W, H, 3);
+fimg_drand48(&noise, 0.1);
+****/
 /* ---------------------------------------------------------------- */
 #define W 320
 #define H 240
 int main(int argc, char *argv[])
 {
 int		foo, idx, opt;
-// char		outname[100];
+float		coef;
+FloatImg 	dessin, noise, result;
+char		outname[100];
 int		gray = 0;
+int		nb_img = 42;
 
 while ((opt = getopt(argc, argv, "gn:v")) != -1) {
 	switch(opt) {
 		case 'g':	gray++;			break;
-		case 'n':	foo=atoi(optarg);	break;
+		case 'n':	nb_img=atoi(optarg);	break;
 		case 'v':	verbosity++;		break;
 		}
 	}
 
 if (verbosity) fimg_print_version(0);
 
-foo = essai_contraste("src.fimg");
 
+foo = fimg_create_from_png("/home/tth/TMP/floatimg/s1.png", &dessin);
+if (foo) {
+	fprintf(stderr, "s1 load err %d\n", foo);
+	exit(1);
+	}
+if (verbosity) fimg_describe(&dessin, "s1 dessin");
+if (gray) fimg_to_gray(&dessin);
+
+foo = fimg_create_from_png("/home/tth/TMP/floatimg/s2.png", &noise);
+if (foo) {
+	fprintf(stderr, "s2 load err %d\n", foo);
+	exit(1);
+	}
+if (verbosity) fimg_describe(&noise, "s2 noise");
+fimg_mul_cste(&noise, 0.50);
+if (gray) fimg_to_gray(&noise);
+
+foo = fimg_create(&result, W, H, 3);
+if (verbosity) fimg_describe(&result, "d result");
+
+fprintf(stderr, "running for %d picz\n", nb_img);
+
+for (idx=0; idx<nb_img; idx++) {
+
+	coef = (float)idx / (float)nb_img;
+	// coef = (0.5-0.5*cos(4*3.141592654*coef));
+
+	foo = fimg_interpolate(&dessin, &noise, &result, coef);
+	printf("%6d    %9.6f\n", idx, coef);
+
+	sprintf(outname, "/home/tth/TMP/floatimg/%05d.pnm", idx);
+	foo = fimg_save_as_pnm(&result, outname, 0);
+	}
+
+/* yes, we can cleanup after work */
+fimg_destroy(&dessin), fimg_destroy(&noise), fimg_destroy(&result);
 
 return 0;
 }