commit avant la Ganguise + push en vrac

doc/the_floatimg_hack.tex

@@ -161,12 +161,27 @@ gris, rgb et rgba\index{rgba}.
 #define FIMG_TYPE_RGBA              4
 \end{verbatim}
 
-Les deux champs suivants (fval et count) sont à la disposition du yuser
+Un peu plus loin, nous avons les pointeurs vers les
-qui peut jouer avec à loisir. 
+différents \textsl{pixmaps} de l'image. En principe l'organisation
+interne de ces zones est improbable, puisque qu'elle dérive
+d'idées approximatives.
+\vspace{1em}
 
-Et pour finir dans la joie, nous avons les pointeurs vers les
+Les deux champs suivants (fval et count) sont à la disposition du
-différents \textsl{pixmaps} de l'image.
+\textsl{yuser}
+qui peut jouer avec à loisir pour faire, par exemple, ce genre de
+chose. Imaginons un périphérique de capture qui nous fournisse des
+images en gris sur 4 bits. Et que nous voulions cumuler\index{cumul}
+quelques images...
+\vspace{1em}
 
+Le champ \textsl{count} sera mis à 0 et 
+le champ \textsl{fval} sera initialisé à 15.0
+(valeur maximale renvoyée par le capteur).
+Ensuite, dans la boucle capture/cumul, \textsl{count} sera
+incrémenté à chaque passe, et nous aurons donc, en finale, 
+toutes les informations nécéssaire pour exploiter au mieux la dynamique
+de notre image dans les étapes ultérieures.
 
 
 
@@ -192,7 +207,7 @@ Bon, vous avez une image latente, et
 vous souhaité dessiner dessus (ou dedans ?) avec vos encres
 flottantes ?
 
-\subsection{funcs/}\index{funcs/}
+\subsection{funcs/}\index{funcs/}\label{funcs}
 
 Une bonne partie de ces fonctions est indéterministe. Ce qui
 veut dire, en langage de tous les soirs, que ça risque de ne
@@ -216,20 +231,34 @@ Dans un avenir incertain, il existera des pages de man\index{man}.
 
 \subsection{mkfimg}\index{mkfimg}\label{mkfimg}
 
-Création d'un fichier contenant une image de teinte constante.
+Création d'un fichier contenant une image de « teinte » constante.
+Cette notion de teinte est assez inconsistante pour le moment,
+puisqu'il n'y a que la valeur par defaut : \textbf{0.0} que
+l'on peut assimiler à un noir absolu\index{absolu}.
 
 \subsection{fimgstats}\index{fimgstats}\label{fimgstats}
 
 Affichage de quelques valeurs calculées à partir d'un fichier
 \texttt{.fimg}\index{.fimg}.
 
-\subsection{fimg2png et fimg2pnm}
+\subsection{fimg2png, fimg2pnm, fimg2tiff}
 		\index{fimg2png}\label{fimg2png}
 		\index{fimg2pnm}\label{fimg2pnm}
+		\index{fimg2tiff}\label{fimg2tiff}
 
-Deux petits proggies pour exporter notre format\index{.fimg} secret
+Quelques petits proggies pour exporter notre format\index{.fimg} secret
-vers des choses plus directement utilisables. 
+vers des choses plus directement utilisables. À condition que le
+code soit écrit et documenté en page \pageref{funcs}.
 
+\subsection{fimg2gray}\index{fimg2gray}\label{fimg2gray}
+
+Nous avons vu dans ce document que chaque image flottante pouvait
+avoir plusieurs plans de réalité. Il ne faut en négliger aucun.
+\vspace{1em}
+
+Il faut quand même deviner que pour passer de l'espace RGB\index{RGB}
+à une abstraction linéaire mono-dimensionnelle, il existe une foultitude
+de méthodes, toutes plus légitimes que les autres.
 
 % -------------------------------------------------------------------
 \section{Video for Linux}\index{v4l2}
@@ -248,7 +277,7 @@ v4l2.
 % -------------------------------------------------------------------
 \section{Et pour la suite ?}
 
-En fait, je fait de la photo par la méthode du « cumul »
+En fait, je fait de la photo par la méthode du « cumul »\index{cumul}
 depuis plusieurs années. Une webcam\index{webcam},
 un Linux\index{Linux}, et ça \textsl{juste marche}.
 Sauf que c'est quand même un peu galère à déplacer, il faut

floatimg.h

@@ -59,6 +59,8 @@ double fimg_timer_set(int whot);
 double fimg_timer_get(int whot);
 
 
+int fimg_mk_gray_from(FloatImg *src, FloatImg*dst, int k);
+
 /*	FIMG files module		*/
 int   fimg_fileinfos(char *fname, int *datas);
 int   fimg_dump_to_file(FloatImg *head, char *fname, int notused);

lib/Makefile

@@ -4,7 +4,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-timers.o operators.o fimg-2gray.o
 DEPS = Makefile ../floatimg.h
 
 # modify it 'as you like'
@@ -23,6 +23,9 @@ t:	t.c ../libfloatimg.a $(DEPS)
 fimg-core.o:	fimg-core.c $(DEPS)
 	gcc $(COPT) -c $<
 
+fimg-2gray.o:	fimg-2gray.c $(DEPS)
+	gcc $(COPT) -c $<
+
 operators.o:	operators.c $(DEPS)
 	gcc $(COPT) -c $<
 

lib/fimg-2gray.c

@@ -0,0 +1,56 @@
+/*
+ *		fimg-2gray.c
+ */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+#include  "string.h"
+
+#include  "../floatimg.h"
+
+extern int verbosity;		/* must be declared around main() */
+
+/* --------------------------------------------------------------------- */
+/*
+ *	floating img MUST be allocated.
+ */
+int fimg_mk_gray_from(FloatImg *src, FloatImg*dst, int k)
+{
+float		kr, kg, kb, kdiv;
+int		nbb, foo;
+
+kr = kg = kb = 1.0;		/* canonic random values */
+kdiv = kr + kg + kb;
+
+/* we must check the validity of our parameters */
+if (FIMG_TYPE_RGB != src->type) {
+	fprintf(stderr, "%s : bad src type %d on %p\n", __func__, 
+				src->type, src);
+	return -8;
+	}
+
+if (FIMG_TYPE_GRAY != dst->type) {
+	fprintf(stderr, "%s : bad dst type %d on %p\n", __func__, 
+				dst->type, dst);
+	return -9;
+	}
+
+/* entering the main processing loop */
+nbb = src->width * src->height;
+
+for (foo=0; foo<nbb; foo++) {
+
+	dst->R[foo] = ( (src->R[foo] * kr) +
+			(src->G[foo] * kg) +
+			(src->B[foo] * kb) ) /
+				kdiv;
+	}
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+
+
+
+

lib/operators.c

@@ -8,6 +8,7 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <string.h>
+#include  <math.h>
 
 #include  "../floatimg.h"
 

lib/t.c

@@ -30,6 +30,16 @@ for (y=0; y<img->height; y++) {
 	}
 
 return -1;
+}
+/* ---------------------------------------------------------------- */
+
+int essai_2gray(FloatImg *picz, char *outname)
+{
+
+
+
+return -1;
+
 }
 /* ---------------------------------------------------------------- */
 #define W 4000
@@ -56,6 +66,10 @@ foo = fimg_create(&result, W, H, 3);
 
 foo = fimg_add(&dessin, &noise, &result);
 fimg_save_as_pnm(&result, "r_add.pnm",  0);
+
+essai_2gray(&result, "gray.pnm");
+
+
 foo = fimg_sub(&dessin, &noise, &result);
 fimg_save_as_pnm(&result, "r_sub.pnm",  0);
 foo = fimg_mul(&dessin, &noise, &result);

tools/mkfimg.c

@@ -19,6 +19,8 @@ int main(int argc, char *argv[])
 int		foo, opt;
 int		width, height;
 char		*fname;
+float		fvalue;
+
 FloatImg	fimg;
 
 while ((opt = getopt(argc, argv, "ho:v")) != -1) {

v4l2/grabvidseq.c

@@ -191,6 +191,7 @@ foo = fimg_create(&cumul,
 		fmt.fmt.pix.width, fmt.fmt.pix.height,
 		FIMG_TYPE_RGB);
 fimg_clear(&cumul);
+cumul.fval = 255.0;
 #endif
 
 
@@ -220,7 +221,8 @@ for (i = 0; i < nbre_capt; i++) {
 		}
 
 	if(verbosity > 1) {
-		printf("%6d   %9.3f\n", i, fimg_timer_get(0));
+		printf("%6d / %6d      %9.3f\n", i, nbre_capt,
+						fimg_timer_get(0));
 		}
 
 
@@ -246,15 +248,13 @@ for (i = 0; i < nbre_capt; i++) {
 #endif
 
 #if SAVE_AS_CUMUL
-	/**
+	/** this is the slow version
 	x_rgb2fimg(buffers[buf.index].start,
 		fmt.fmt.pix.width, fmt.fmt.pix.height, &grab);
 	fimg_add(&grab, &cumul, &cumul);
 	**/
 	x_add_rgb2fimg(buffers[buf.index].start,
 		fmt.fmt.pix.width, fmt.fmt.pix.height, &cumul);
-
-
 #endif
 
 #if SAVE_AS_FIMG

v4l2/rgb2fimg.c

@@ -5,6 +5,11 @@
 
 #include  "funcs.h"
 
+/*
+ *		Be careful, these functions are not yet fireproof,
+ *		and calling conventions are fluctuating.
+ */
+
 /* --------------------------------------------------------------------- */
 int x_upscaler(unsigned char *src, int w, int h, FloatImg *d)
 {
@@ -13,6 +18,14 @@ int				x, y, xx, yy;
 float				r, g, b;
 static unsigned short		modz;
 
+/*
+ *	check in image sizes are correct
+ */
+if ( d->width != w*2 || d->height != h*2 ) {
+	fprintf(stderr, "%s : dimension error\n", __func__);
+	return -2;
+	}
+
 // rp = d->R, gp = d->G, bp = d->B;
 
 for (y=0; y<h; y++) {
@@ -49,7 +62,6 @@ for (iter=0; iter<size; iter++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
 int x_add_rgb2fimg(unsigned char *src, int w, int h, FloatImg *d)
 {
 int			iter, size;
@@ -64,8 +76,12 @@ for (iter=0; iter<size; iter++) {
 	*bp++ += (float)*src++;
 	}
 
+d->count++;		/* one more frame in the accumulator */
+
 return 0;
 }
+/* --------------------------------------------------------------------- */
+
 int x_rgb2file(unsigned char *src, int w, int h, char *fname)
 {
 FloatImg		buff;

v4l2/t.c

@@ -33,7 +33,6 @@ if (verbosity) fprintf(stderr, "\topen %s -> %d\n", dev, vfd);
 
 memset(&fmt, 0, sizeof(fmt));
 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-// pr_v4l2_format("before ioctl", &fmt);
 
 foo = ioctl(vfd, VIDIOC_G_FMT, &fmt);
 fprintf(stderr, "ioctl -> %d\n", foo);
@@ -42,25 +41,18 @@ if (0 != foo)	{
 	exit(1);
 	}
 
-pr_v4l2_format("after ioctl", &fmt);
+pr_v4l2_format("after ioctl VIDIOC_G_FMT", &fmt);
 
 
 return k;
 }
 /* --------------------------------------------------------------------- */
-int liste_des_devices(int K)
-{
-fprintf(stderr, "%s not implemented\n", __func__);
-return -1;
-}
-/* --------------------------------------------------------------------- */
 
 void help(int k)
 {
 puts("Options :");
 puts("\t-d\tselect the video device");
 puts("\t-K\tset the K parameter");
-puts("\t-l\tlist video devices");
 puts("\t-v\tincrease verbosity");
 
 if (verbosity) { puts(""); fimg_print_version(1); }

v4l2/video-infos.c

@@ -95,7 +95,7 @@ return 0;
 int enum_controls(int fd, char *txt, int k)
 {
 struct v4l2_queryctrl		qctrl;
-int				foo, idx;
+int				idx;
 
 
 printf("-- controls enumeration '%s'\n", txt);
@@ -208,7 +208,6 @@ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 foo = ioctl(vfd, VIDIOC_G_FMT, &fmt);
 if (0 != foo)	{
 	perror("ioctl G_FMT");
-	// exit(1);
 	}
 else	{
 	pr_v4l2_format("Experimental", &fmt);
@@ -249,9 +248,13 @@ static void print_title(char *txt)
 int	foo, l;
 
 l = strlen(txt);
-for (foo=0; foo<l+18; foo++)	putchar('*');	puts("");
+for (foo=0; foo<l+18; foo++)
+	putchar('*');
+puts("");
 printf("******   %s   ******\n", txt);
-for (foo=0; foo<l+18; foo++)	putchar('*');	puts("\n");
+for (foo=0; foo<l+18; foo++)
+	putchar('*');
+puts("\n");
 }
 /* --------------------------------------------------------------------- */
 int main(int argc, char *argv[])