clean the code

build.sh

@@ -27,10 +27,10 @@ build v4l2
 
 # ------------------------------------------------------------------
 
-echo '*************************'
 
 make
 
+# ------------------------------------------------------------------
 
 
 

doc/the_floatimg_hack.tex

@@ -24,16 +24,164 @@
 \section{Image flottante ?}
 
 De quoi parle-t-on exactement ?
+\vspace{1em}
+
+Traditionnellement, les valeurs des pixels dans les images
+informatiques sont mémorisées sur 8 bits, un octet\index{octet},
+soit 256 valeurs différentes.
+Ceci dit, on trouve parfois des images codées sur 16 bits par
+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.
 
 % -------------------------------------------------------------------
 
 \tableofcontents
+\pagebreak
 
 % -------------------------------------------------------------------
-\section{Example}
+\section{Example}\index{example}\label{example}
+
+Pour commencer par quelques chose de simple, 
+nous allons créer une image RGB\index{RGB} complètement noire,
+puis l'enregistrer dans un fichier \texttt{.fimg}\index{.fimg},
+un format complètement inconnu, puisque je viens de l'inventer
+à l'instant même.
+
+Tout d'abord, nous devons déclarer et garnir quelques variables
+pour gérer la machinerie interne.
+
+\begin{verbatim}
+int             width = 640, height = 480;
+char            *fname = "exemple.fimg";
+FloatImg        fimg;
+\end{verbatim}
+
+Ensuite, nous enchainerons trois étapes : création de l'image
+en mémoire centrale, initialisations des valeurs de pixel à 0.0,
+et pour conclure, enregistrement dans un fichier.
+
+\begin{verbatim}
+foo = fimg_create(&fimg, width, height, 3);
+if (foo) {
+        fprintf(stderr, "create floatimg -> %d\n", foo);
+        exit(1);
+        }
+fimg_clear(&fimg);
+foo = fimg_dump_to_file(&fimg, fname, 0);
+if (foo) {
+        fprintf(stderr, "dump fimg -> %d\n", foo);
+        exit(1);
+        }
+\end{verbatim}
+
+
+Une fois ce code enrobé dans un \texttt{main()}, compilé et exécuté,
+nous pouvons entrevoir, grâce au logiciel
+\texttt{fimgstats} (voir page \pageref{fimgstats}),
+le résultat sous forme de chiffres divers, et/ou inutiles~:
+
+\begin{verbatim}
+$ ./fimgstats quux.img 
+----------- numbers from 'quux.img' :
+  640    480   3  0x7f3718c4f010 0x7f3718d7b010 0x7f3718ea7010
+surface      307200
+mean values:
+      R         0.000000
+      G         0.000000
+      B         0.000000
+      A         0.000000
+max value     0.000000
+\end{verbatim}
+
+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, décrits page \pageref{outils}.
 
 % -------------------------------------------------------------------
-\section{Les outils}
+\section{Installation}
+
+Pour le moment, la procédure d'installation est un peu rude,
+pour ne pas dire clairement sommaire.
+Un script \texttt{build.sh} permet de construire approximativement 
+le bouzin. Il est loin d'être parfait.
+\vspace{1em}
+
+Si le résultat vous semble correct, vous pouvez copier 
+les deux fichiers \texttt{floatimg.h} et \texttt{libfloatimg.a}
+dans un emplacement
+approprié, par exemple
+\texttt{/usr/local/include} et \texttt{/usr/local/lib}.
+
+% -------------------------------------------------------------------
+\section{Utilisation}
+
+Classiquement, il y a un fichier à inclure, \texttt{floatimg.h},
+contenant un certain nombre de
+définition de structures, de macros, 
+de constantes\footnote{À l'ancienne, via le pré-processur} 
+et les prototypes des fonctions utilisables.
+\vspace{1em}
+
+Au niveau du code source, ces fonctions sont approximativement
+classées en deux catégories : \texttt{lib/} et \texttt{funcs/}.
+La première contient les choses qui sont relativement figées,
+et la seconde celles qui risquent de bouger. Cette classification
+est en fait arbitraire.
+
+\subsection{lib/}\index{lib/}
+
+Première chose, la gestion dynamique de la mémoire occupées
+par tous ces pixels flottants est faite par ces deux fonctions~:
+
+\begin{verbatim}
+int fimg_create(FloatImg *fimg, int w, int h, int type);
+int fimg_destroy(FloatImg *fimg);
+\end{verbatim}
+
+Les types d'images actuellement gérés sont les trois grands
+classiques : gray, rgb et rgba. Il y a les constantes adéquates
+dans \texttt{floatimg.h}.
+
+\subsection{funcs/}\index{funcs/}
+
+
+% -------------------------------------------------------------------
+\section{Les outils}\label{outils}
+
+\textsl{3615mavie} : sur des projets comme celui-ci, qui travaillent
+in-fine sur des objets que l'on peut considérer comme « physiques »,
+il est important de passer à une utilisation
+normale\footnote{Il y a une vie en dehors de git.} et construire
+des trucs qui mettent en action le code primitif.
+% \vspace{1em}
+
+
+\subsection{mkfimg}\index{mkfimg}\label{mkfimg}
+
+Création d'un fichier contenant une image de teinte constante.
+
+\subsection{fimgstats}\index{fimgstats}\label{fimgstats}
+
+Affichage de quelques valeurs calculées à partir d'un fichier
+\texttt{.fimg}\index{.fimg}.
+
+% -------------------------------------------------------------------
+\section{Video for Linux}\index{v4l2}
+
+Donc, maintenant, nous savons un peu tripoter des images flottantes.
+Et nous devons nous poser une question fondamentale\footnote{primitive ?}
+sur la provenance de ces données prétendant être des images.
+
+% -------------------------------------------------------------------
+\section{Et pour la suite ?}
+
+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
+avoir un shell pour déclencher, c'est pas facile\dots
 
 % -------------------------------------------------------------------
 

floatimg.h

@@ -2,7 +2,7 @@
  *	floatimg.h
  */
 
-#define		FIMG_VERSION	62
+#define		FIMG_VERSION	64
 
 /*
  *	in memory descriptor
@@ -27,6 +27,11 @@ typedef struct {
 	int		w, h, t;
 	} FimgFileHead;
 
+
+#define FIMG_TYPE_GRAY			1
+#define FIMG_TYPE_RGB			3
+#define FIMG_TYPE_RGBA			4
+
 /*
  *	core module
  */

lib/fimg-core.c

@@ -14,14 +14,26 @@
 extern int verbosity;		/* must be declared around main() */
 
 /* ---------------------------------------------------------------- */
-static int fimg_type_is_valid(int t)
+static int fimg_type_is_valid(int type)
 {
-switch (t) {
+switch (type) {
- 	case 1: case 3: case 4:		return 1;
+ 	case FIMG_TYPE_GRAY:
+	case FIMG_TYPE_RGB:
+	case FIMG_TYPE_RGBA:		return 1;
 	}
 return 0;
 }
 /* --------------------------------------------------------------------- */
+static char *fimg_str_type(int type)
+{
+switch (type) {
+ 	case FIMG_TYPE_GRAY:		return "gray";
+	case FIMG_TYPE_RGB:		return "rgb";
+	case FIMG_TYPE_RGBA:		return "rgba";
+	}
+return "???";
+}
+/* --------------------------------------------------------------------- */
 int fimg_print_version(int k)
 {
 fprintf(stderr, "*** FloatImg library, alpha v%d (%s, %s)\n",
@@ -52,9 +64,11 @@ if( ! fimg_type_is_valid(head->type) ) {
 	return -1;
 	}
 
-printf("    size     %d x %d  x %d\n",
+printf("    type     %d\n", head->type);
-			head->width, head->height, head->type);
+printf("    dims     %d x %d\n",
+			head->width, head->height);
 printf(" fval/count  %f  %d\n", head->fval, head->count);
+
 printf("    pixels@  %p  %p  %p %p\n",
 			head->R, head->G, head->B, head->A);
 
@@ -74,10 +88,11 @@ fprintf(stderr, ">>> %-25s ( %p %d %d %d )\n", __func__, fimg, w, h, t);
 if ( ! fimg_type_is_valid(t) ) {
 	return -2;
 	}
+
 memset(fimg, 0, sizeof(FloatImg));
 
 surface = w * h;
-size    = surface * t * sizeof(float);			
+size    = surface * t * sizeof(float);
 #if DEBUG_LEVEL > 1
 fprintf(stderr, "surface is %d pixels, need %d bytes\n", surface, size);
 #endif
@@ -96,11 +111,12 @@ fimg->width = w;	fimg->height = h;
 fimg->type = t;
 
 fimg->R = fptr;	
-if ( (t==3) || (t==4) ) {
+if ( (t==FIMG_TYPE_RGB) || (t==FIMG_TYPE_RGBA) ) {
 	fimg->G = fptr + surface;
 	fimg->B = fptr + surface + surface;
 	}
-if ( t==4 )	fimg->A = fptr + (3 * surface); 
+if ( t==FIMG_TYPE_RGBA )	fimg->A = fptr + (3 * surface); 
+/* ok this a really WTF fragment of code */
 
 return 0;
 }
@@ -119,10 +135,12 @@ if (NULL == fimg) {
 	}
 
 if ( ! fimg_type_is_valid(fimg->type) ) {
+	fprintf(stderr, "%s : type %d invalid\n", __func__,
+					fimg->type);
 	return -2;
 	}
 if (NULL == fimg->R) {
-	fprintf(stderr, "%s : %p already freeed\n", __func__, fimg);
+	fprintf(stderr, "%s : %p already freed\n", __func__, fimg);
 	return -3;
 	}
 free(fimg->R);
@@ -146,7 +164,7 @@ if ( ! fimg_type_is_valid(fimg->type) ) {
 size = fimg->width * fimg->height * fimg->type * sizeof(float);		
 memset(fimg->R, 0, size);
 
-return -1;
+return 0;
 }
 /* --------------------------------------------------------------------- */
 

lib/t.c

@@ -1,7 +1,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  <unistd.h>
-#include  "string.h"
+#include  <string.h>
 
 #include  "../floatimg.h"
 
@@ -16,9 +16,11 @@ int		datas[3];
 
 verbosity = 1;
 
+fimg_print_version(0);
+
 foo = fimg_create(&fimg, 640, 480, 3);
 
-printf("retour du truc ---> %d\n", foo);
+printf("retour fimg_create ---> %d\n", foo);
 
 fimg_printhead(&fimg);