build.sh

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

doc/the_floatimg_hack.tex

@@ -24,164 +24,16 @@
 \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}\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{Example}
 
 % -------------------------------------------------------------------
-\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
+\section{Les outils}
 
 % -------------------------------------------------------------------
 

floatimg.h

@@ -2,7 +2,7 @@
  *	floatimg.h
  */
 
-#define		FIMG_VERSION	64
+#define		FIMG_VERSION	62
 
 /*
  *	in memory descriptor
@@ -27,11 +27,6 @@ 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,26 +14,14 @@
 extern int verbosity;		/* must be declared around main() */
 
 /* ---------------------------------------------------------------- */
-static int fimg_type_is_valid(int type)
+static int fimg_type_is_valid(int t)
 {
-switch (type) {
- 	case FIMG_TYPE_GRAY:
-	case FIMG_TYPE_RGB:
-	case FIMG_TYPE_RGBA:		return 1;
+switch (t) {
+ 	case 1: case 3: case 4:		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",
@@ -64,11 +52,9 @@ if( ! fimg_type_is_valid(head->type) ) {
 	return -1;
 	}
 
-printf("    type     %d\n", head->type);
-printf("    dims     %d x %d\n",
-			head->width, head->height);
+printf("    size     %d x %d  x %d\n",
+			head->width, head->height, head->type);
 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);
 
@@ -88,7 +74,6 @@ 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;
@@ -111,12 +96,11 @@ fimg->width = w;	fimg->height = h;
 fimg->type = t;
 
 fimg->R = fptr;	
-if ( (t==FIMG_TYPE_RGB) || (t==FIMG_TYPE_RGBA) ) {
+if ( (t==3) || (t==4) ) {
 	fimg->G = fptr + surface;
 	fimg->B = fptr + surface + surface;
 	}
-if ( t==FIMG_TYPE_RGBA )	fimg->A = fptr + (3 * surface); 
-/* ok this a really WTF fragment of code */
+if ( t==4 )	fimg->A = fptr + (3 * surface); 
 
 return 0;
 }
@@ -135,12 +119,10 @@ 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 freed\n", __func__, fimg);
+	fprintf(stderr, "%s : %p already freeed\n", __func__, fimg);
 	return -3;
 	}
 free(fimg->R);
@@ -164,7 +146,7 @@ if ( ! fimg_type_is_valid(fimg->type) ) {
 size = fimg->width * fimg->height * fimg->type * sizeof(float);		
 memset(fimg->R, 0, size);
 
-return 0;
+return -1;
 }
 /* --------------------------------------------------------------------- */
 

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,11 +16,9 @@ int		datas[3];
 
 verbosity = 1;
 
-fimg_print_version(0);
-
 foo = fimg_create(&fimg, 640, 480, 3);
 
-printf("retour fimg_create ---> %d\n", foo);
+printf("retour du truc ---> %d\n", foo);
 
 fimg_printhead(&fimg);