doc/the_floatimg_hack.tex

@@ -161,27 +161,12 @@ gris, rgb et rgba\index{rgba}.
 #define FIMG_TYPE_RGBA              4
 \end{verbatim}
 
-Un peu plus loin, nous avons les pointeurs vers les
+Les deux champs suivants (fval et count) sont à la disposition du yuser
-différents \textsl{pixmaps} de l'image. En principe l'organisation
+qui peut jouer avec à loisir. 
-interne de ces zones est improbable, puisque qu'elle dérive
-d'idées approximatives.
-\vspace{1em}
 
-Les deux champs suivants (fval et count) sont à la disposition du
+Et pour finir dans la joie, nous avons les pointeurs vers les
-\textsl{yuser}
+différents \textsl{pixmaps} de l'image.
-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.
 
 
 
@@ -207,7 +192,7 @@ Bon, vous avez une image latente, et
 vous souhaité dessiner dessus (ou dedans ?) avec vos encres
 flottantes ?
 
-\subsection{funcs/}\index{funcs/}\label{funcs}
+\subsection{funcs/}\index{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
@@ -231,34 +216,20 @@ 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, fimg2pnm, fimg2tiff}
+\subsection{fimg2png et fimg2pnm}
 		\index{fimg2png}\label{fimg2png}
 		\index{fimg2pnm}\label{fimg2pnm}
-		\index{fimg2tiff}\label{fimg2tiff}
 
-Quelques petits proggies pour exporter notre format\index{.fimg} secret
+Deux petits proggies pour exporter notre format\index{.fimg} secret
-vers des choses plus directement utilisables. À condition que le
+vers des choses plus directement utilisables. 
-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}
@@ -277,7 +248,7 @@ v4l2.
 % -------------------------------------------------------------------
 \section{Et pour la suite ?}
 
-En fait, je fait de la photo par la méthode du « cumul »\index{cumul}
+En fait, je fait de la photo par la méthode du « 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,8 +59,6 @@ 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-2gray.o
+	fimg-timers.o operators.o
 DEPS = Makefile ../floatimg.h
 
 # modify it 'as you like'
@@ -23,9 +23,6 @@ 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

@@ -1,56 +0,0 @@
-/*
- *		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,7 +8,6 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 #include  <string.h>
-#include  <math.h>
 
 #include  "../floatimg.h"
 

lib/t.c

@@ -30,16 +30,6 @@ for (y=0; y<img->height; y++) {
 	}
 
 return -1;
-}
-/* ---------------------------------------------------------------- */
-
-int essai_2gray(FloatImg *picz, char *outname)
-{
-
-
-
-return -1;
-
 }
 /* ---------------------------------------------------------------- */
 #define W 4000
@@ -66,10 +56,6 @@ 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,8 +19,6 @@ 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,7 +191,6 @@ foo = fimg_create(&cumul,
 		fmt.fmt.pix.width, fmt.fmt.pix.height,
 		FIMG_TYPE_RGB);
 fimg_clear(&cumul);
-cumul.fval = 255.0;
 #endif
 
 
@@ -221,8 +220,7 @@ for (i = 0; i < nbre_capt; i++) {
 		}
 
 	if(verbosity > 1) {
-		printf("%6d / %6d      %9.3f\n", i, nbre_capt,
+		printf("%6d   %9.3f\n", i, fimg_timer_get(0));
-						fimg_timer_get(0));
 		}
 
 
@@ -248,13 +246,15 @@ 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,11 +5,6 @@
 
 #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)
 {
@@ -18,14 +13,6 @@ 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++) {
@@ -62,6 +49,7 @@ for (iter=0; iter<size; iter++) {
 return 0;
 }
 /* --------------------------------------------------------------------- */
+/* --------------------------------------------------------------------- */
 int x_add_rgb2fimg(unsigned char *src, int w, int h, FloatImg *d)
 {
 int			iter, size;
@@ -76,12 +64,8 @@ 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,6 +33,7 @@ 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);
@@ -41,18 +42,25 @@ if (0 != foo)	{
 	exit(1);
 	}
 
-pr_v4l2_format("after ioctl VIDIOC_G_FMT", &fmt);
+pr_v4l2_format("after ioctl", &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				idx;
+int				foo, idx;
 
 
 printf("-- controls enumeration '%s'\n", txt);
@@ -208,6 +208,7 @@ 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);
@@ -248,13 +249,9 @@ static void print_title(char *txt)
 int	foo, l;
 
 l = strlen(txt);
-for (foo=0; foo<l+18; foo++)
+for (foo=0; foo<l+18; foo++)	putchar('*');	puts("");
-	putchar('*');
-puts("");
 printf("******   %s   ******\n", txt);
-for (foo=0; foo<l+18; foo++)
+for (foo=0; foo<l+18; foo++)	putchar('*');	puts("\n");
-	putchar('*');
-puts("\n");
 }
 /* --------------------------------------------------------------------- */
 int main(int argc, char *argv[])