added and debugged first filter function

doc/the_floatimg_hack.tex

@@ -138,18 +138,18 @@ un format complètement inconnu, puisque je viens de l'inventer
 Tout d'abord, nous devons déclarer et garnir quelques variables
 pour gérer la machinerie interne.
 
-\begin{verbatim}
+\begin{lstlisting}
 int             width = 640, height = 480;
 char            *fname = "exemple.fimg";
 FloatImg        fimg;
-\end{verbatim}
+\end{lstlisting}
 
 Ensuite, nous enchainerons trois étapes : création de l'image
 en mémoire centrale, initialisation des valeurs de chaque pixel à 0.0,
 et pour conclure, enregistrement dans un fichier\footnote{Au format
 ésotérique, mais très véloce.} binaire.
 
-\begin{verbatim}
+\begin{lstlisting}
 foo = fimg_create(&fimg, width, height, FIMG_TYPE_RGB);
 if (foo) {
         fprintf(stderr, "create floatimg -> %d\n", foo);
@@ -161,7 +161,7 @@ if (foo) {
         fprintf(stderr, "dump fimg -> %d\n", foo);
         exit(1);
         }
-\end{verbatim}
+\end{lstlisting}
 
 
 Une fois ce code enrobé dans un \texttt{main()}, compilé et exécuté,
@@ -261,7 +261,7 @@ sont décrits par un ensemble
 de données (certains appelent ça des \textsl{metadatas}) regroupées
 dans une jolie structure que nous allons examiner dès maintenant.
 
-\begin{verbatim}
+\begin{lstlisting}
 /*      in memory descriptor */
 typedef struct {
         int             width;
@@ -272,7 +272,7 @@ typedef struct {
         float           *R, *G, *B, *A;
         int             reserved;
         } FloatImg;
-\end{verbatim}\index{FloatImg}
+\end{lstlisting}\index{FloatImg}
 
 Les deux premiers champs sont \textsl{obvious}.
 Le troisième est le type d'image : pour le moment, il y en a trois
@@ -280,12 +280,12 @@ qui sont définis\footnote{et plus ou moins bien gérés\dots} :
 gris, rgb et rgba\index{rgba}.
 Les constantes adéquates sont dans \texttt{floatimg.h}
 
-\begin{verbatim}
+\begin{lstlisting}
 #define FIMG_TYPE_GRAY              1
 #define FIMG_TYPE_RGB               3
 #define FIMG_TYPE_RGBA              4
 #define FIMG_TYPE_RGBZ              99
-\end{verbatim}
+\end{lstlisting}
 
 Un peu plus loin, nous avons les pointeurs vers les
 différents \textsl{pixmaps} de l'image. En principe l'organisation
@@ -324,10 +324,10 @@ dynamique de la mémoire qui sera occupée par tous ces pixels flottants,
 ce qui est un sujet parfois délicat\footnote{GC or not GC ?}.
 Elle est donc faite, à la base, par ces deux fonctions~:
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_create(FloatImg *fimg, int w, int h, int type);
 int fimg_destroy(FloatImg *fimg);
-\end{verbatim}
+\end{lstlisting}
 
 L'appelant doit lui-même gérer le descripteur d'image (une structure
 C décrite plus haut) en le considérant comme un type semi-opaque dont
@@ -341,10 +341,10 @@ pouvoir aussi exister à long terme en étant stocké dans la matrice
 est tout aussi pertinent. Il y a deux opérations qui supportent le
 reste des transits ram/ps.
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused);
 int fimg_load_from_dump(char *fname, FloatImg *where);
-\end{verbatim}
+\end{lstlisting}
 
 Recharger une image depuis un fichier nécessite que celle-ci et
 l'image de destination en mémoire 
@@ -365,11 +365,11 @@ simple, une fonction qui enchaine ces deux actions
 (allocation, puis lecture), et s'utilise
 comme ça :
 
-\begin{verbatim}
+\begin{lstlisting}
 FloatImg       head;
 memset(&head, 0, sizeof(FloatImg));
 foo = fimg_create_from_dump("lena.fimg", &head);
-\end{verbatim}
+\end{lstlisting}
 
 Si la valeur retournée est différente de 0, c'est que quelque
 chose s'est mal passé.
@@ -383,9 +383,9 @@ Bon, vous avez une image latente, et vous souhaitez dessiner dessus
 (ou dedans ?) avec vos encres flottantes ?
 Il y a des fonctions pour ça, par exemple~:
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_plot_rgb(FloatImg *head, int x, int y, float r, float g, float b);
-\end{verbatim}
+\end{lstlisting}
 
 Les paramètres sont explicites, mais leur validité doit être
 sévèrement controlée par l'appelant. Il y a une fonction 
@@ -420,13 +420,13 @@ est un nombre en double précision donnant la valeur
 maximale \textsl{supposée} de l'image source,
 valeur qui peut être déterminée de plusieurs manières.
 
-\begin{verbatim}
+\begin{lstlisting}
 /* source in lib/contrast.c */
 int fimg_square_root(FloatImg *s, FloatImg *d, double maxval);
 int fimg_power_2(FloatImg *s, FloatImg *d, double maxval);
 int fimg_cos_01(FloatImg *s, FloatImg *d, double maxval);
 int fimg_cos_010(FloatImg *s, FloatImg *d, double maxval);
-\end{verbatim}
+\end{lstlisting}
 
 
 Si vous souhaitez rajouter votre propre méthode de modification
@@ -475,10 +475,10 @@ de pixel flottant.
 
 Très prochainement, le retour du blitter\index{blitter}.
 
-\begin{verbatim}
+\begin{lstlisting}
 /*	module funcs/geometry.c		*/
 int fimg_halfsize_0(FloatImg *src, FloatImg *dst, int notused);
-\end{verbatim}
+\end{lstlisting}
 
 Attention lors de l'appel, le descripteur \texttt{dst} ne doit pas
 contenir d'image, et doit être effacé avec un bon
@@ -510,9 +510,9 @@ l'utilisation du codage \textsc{ascii}\index{ascii}
 (alors qu'on pourrait mettre du binaire, plus compact) y est
 pour quelque chose.
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_save_as_pnm(FloatImg *head, char *fname, int flags);
-\end{verbatim}
+\end{lstlisting}
 
 Le bit \texttt{0} du paramètre \texttt{flags} mis à \texttt{1} demande
 à la fonction de faire la mise à l'échelle avec le couple
@@ -533,9 +533,9 @@ mais on a quand même une bonne compression, ça compense.
 J'utilise \textsl{libpnglite} avec qui j'ai un peu de mal à suivre.
 Mais je me soigne. Le mode 16 bits va bientôt arriver.
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_save_as_png(FloatImg *src, char *outname, int flags);
-\end{verbatim}
+\end{lstlisting}
 
 Tous les flags doivent être à zéro.
 
@@ -561,10 +561,10 @@ dans des domaines annexes,
 tels que l'interprétation d'arguments dans la ligne de commande ou un
 fichier de configuration.
 
-\begin{verbatim}
+\begin{lstlisting}
 int parse_WxH(char *str, int *pw, int *ph)
 int parse_double(char *str, double *dptr)
-\end{verbatim}
+\end{lstlisting}
 
 
 La fonction \texttt{int format\_from\_extension(char *fname)} examine un
@@ -580,20 +580,27 @@ To be continued\index{XXX}
 
 Quelques routines qui servent futilement à \textsl{brotcher} les images.
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_killcolors_a(FloatImg *fimg, float fval);
 int fimg_killcolors_b(FloatImg *fimg, float fval);
-\end{verbatim}
+\end{lstlisting}
+
 
 
 %		----------------------------------
 
 
-\subsection{Filtrages}
+\subsection{Filtrages}\index{filtrage}
 
-To be done\index{XXX}, et il faut que je réfléchisse au traitement
-des bords d'image.
+Pour commencer, il faut que je réfléchisse au traitement
+des bordures des images.
+Ensuite que je débuggue\index{bug} cette fonction~:
 
+\begin{lstlisting}
+int fimg_lissage_2x2(FloatImg *img);
+\end{lstlisting}
+
+To be continued\index{XXX}\dots
 
 %		----------------------------------
 
@@ -614,7 +621,7 @@ Pour simplifier les choses, nous n'allons traiter que les
 images de type \textsc{FIMG\_TYPE\_RGB}, de loin le plus
 répandu par les temps qui courent.
 
-\begin{verbatim}
+\begin{lstlisting}
 int fimg_example(FloatImg *s, FloatImg *d, float value)
 {
 int     size, index;
@@ -633,7 +640,7 @@ for (idx=0; idx<size; idx++) {
 
 return 0;
 }
-\end{verbatim}
+\end{lstlisting}
 
 Je vous laisse imaginer les dégats que peut faire cette 
 fontion en utilisation réelle. Mieux, je vous propose
@@ -648,7 +655,7 @@ de fonctions prévues à cet effet..
 % -------------------------------------------------------------------
 \section{Les outils}\label{outils}
 
-\textsl{3615mavie} : sur des projets comme celui-ci, qui travaillent
+\textsf{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
@@ -694,7 +701,7 @@ devra être donné avec l'option \texttt{-k F.F} avec une valeur par défaut
 
 \subsection{png2fimg}\index{png2fimg}\label{png2fimg}
 
-Grosse panne à réparer.
+Grosse panne\index{bug} à réparer.
 
 \begin{verbatim}
 tth@debian:~/TMP/floatimg$ png2fimg A.png foo.fimg
@@ -753,8 +760,9 @@ sera lisible avec le sélecteur \texttt{-L}.
 \subsection{fimgops}\index{fimgops}\label{fimgops}
 
 Quelques opérations diverses entre deux images, qui doivent être
-de la même taille, et du même type \textsl{pour le moment,
-uniquement RGB}.
+de la même taille, et uniquement du type \textsl{RGB}. Certaines
+de ces opérations peuvent avoir un effet étrange sur vos images,
+par exemple si un pixel se retrouve avec une valeur négative.
 
 \begin{verbatim}
 usage:
@@ -770,6 +778,7 @@ options:
         -g              convert output to gray
         -k N.N          set float value
         -v              increase verbosity
+        -X              explosive action
 \end{verbatim}
 
 Pour des operateurs paramétrable (comme \texttt{mix}), le paramêtre
@@ -791,6 +800,9 @@ D'un autre coté, écrire un greffon d'import/export pour
 Gimp\index{Gimp} ou Imagemagick\index{Imagemagick} ou Krita\index{Krita}
 ne devrait pas être trop difficile. Des volontaires ?
 
+\textsl{D'ailleurs, pourquoi $n$ logiciels indépendants alors q'un
+seul devrait être nécessaire ?}
+
 \subsection{fimg2gray}\index{fimg2gray}\label{fimg2gray}
 
 Nous avons vu dans ce document que chaque image flottante pouvait
@@ -836,7 +848,6 @@ nous faisons la somme de plusieurs centaines de ces images ?
 ACCU="quux.fimg"
 TMPF="tmp.fimg"
 DIMS="320 240"
-
 mkfimg $ACCU $DIMS
 for i in {0..1000}
 do

floatimg.h

@@ -2,7 +2,7 @@
  *	floatimg.h
  */
 
-#define		FIMG_VERSION	93
+#define		FIMG_VERSION	94
 
 /*
  *	in memory descriptor
@@ -80,6 +80,9 @@ int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
 
 
+int fimg_killborders(FloatImg *img);
+int fimg_lissage_2x2(FloatImg *img);
+
 /*	'sfx0' module 			*/
 int fimg_killcolors_a(FloatImg *fimg, float fval);
 int fimg_killcolors_b(FloatImg *fimg, float fval);

funcs/filtrage.c

@@ -10,6 +10,8 @@
 int fimg_lissage_2x2(FloatImg *img)
 {
 int		x, y, offset;
+float		cr, cg, cb;
+float		*pr, *pg, *pb;
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
@@ -17,15 +19,77 @@ fprintf(stderr,"     type %d size %dx%d\n", img->type,
 					img->width, img->height);
 #endif
 
-for (y=1; y<img->height; y++) {
+pr = img->R;	pg = img->G;	pb = img->B;
 
-	for (x=1; x<img->width; x++) {
+for (y=1; y < img->height-1; y++) {
+
+	for (x=1; x < img->width-1; x++) {
 
 		offset = x + (y * img->width);
 
+	cr =	pr[offset]		+	pr[offset+1]	+
+		pr[offset+img->width]	+	pr[offset+img->width+1];
+
+	cg =	pg[offset]		+	pg[offset+1]	+
+		pg[offset+img->width]	+	pg[offset+img->width+1];
+
+	cb =	pb[offset]		+	pb[offset+1]	+
+		pb[offset+img->width]	+	pb[offset+img->width+1];
+
+	pr[offset] = cr / 4.0;
+	pg[offset] = cg / 4.0;
+	pb[offset] = cb / 4.0;
+
 	}
 }
 
+return 0;
+}
+/* -------------------------------------------------------------------- */
+int fimg_killborders(FloatImg *img)
+{
+int		idx, h, w, o;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
+fprintf(stderr,"     type %d size %dx%d\n", img->type,
+					img->width, img->height);
+#endif
+
+h = img->height;	w = img->width;
+
+for (idx=0; idx<h; idx++) {
+
+#define FAST 1
+
+#if FAST
+	img->R[idx*w] = 0.0;
+	img->G[idx*w] = 0.0;
+	img->B[idx*w] = 0.0;
+	img->R[(idx*w)+w-1] = 0.0;
+	img->G[(idx*w)+w-1] = 0.0;
+	img->B[(idx*w)+w-1] = 0.0;
+#else
+	fimg_plot_rgb(img, 0, idx, 0.0, 0.0, 0.0);
+	fimg_plot_rgb(img, w-1, idx, 0.0, 0.0, 0.0);
+#endif
+	}
+
+o = w * (h - 1);
+
+for (idx=0; idx<w; idx++) {
+#if FAST
+	img->R[idx] = 0.0;
+	img->G[idx] = 0.0;
+	img->B[idx] = 0.0;
+	img->R[idx+o] = 0.0;
+	img->G[idx+o] = 0.0;
+	img->B[idx+o] = 0.0;
+#else
+	fimg_plot_rgb(img, idx, 0, 0.0, 0.0, 0.0);
+	fimg_plot_rgb(img, idx, h-1, 0.0, 0.0, 0.0);
+#endif
+	}
 return -1;
 }
 /* -------------------------------------------------------------------- */

funcs/t.c

@@ -12,6 +12,40 @@ int		verbosity;
 
 float		global_fvalue;
 
+/* --------------------------------------------------------------------- */
+int essai_filtrage(char *infile)
+{
+FloatImg	fimg;
+int		foo, idx;
+char		buffer[100];
+
+if (NULL != infile) {
+	fprintf(stderr, "loading %s\n", infile);
+	foo = fimg_create_from_dump(infile, &fimg);
+	if (foo) {
+		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
+		return foo;
+		}
+	}
+else	{
+	fprintf(stderr, "%s is creating the picz\n", __func__);
+	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
+	fimg_draw_something(&fimg);
+	}
+
+foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);
+
+for (idx=0; idx<20; idx++) {
+	foo = fimg_lissage_2x2(&fimg);
+	foo = fimg_killborders(&fimg);
+	sprintf(buffer, "filter%03d.pnm", idx);
+	foo = fimg_save_as_pnm(&fimg, buffer, 0);
+	}
+
+fimg_destroy(&fimg);
+
+return 0;
+}
 /* --------------------------------------------------------------------- */
 int essai_geometrie(char *infile)
 {
@@ -173,6 +207,7 @@ return 0;
 int main(int argc, char *argv[])
 {
 int		foo, opt;
+char		*filename;
 
 puts("++++++++++++++++++++++++++++++++");
 
@@ -186,9 +221,14 @@ while ((opt = getopt(argc, argv, "hk:v")) != -1) {
 		}
 	}
 
-foo = essai_geometrie("foo.fimg");
+fprintf(stderr, "argc %d   optind %d\n", argc, optind);
+
+filename = NULL;
+if (1 == argc-optind)	filename = argv[optind];
+
+foo = essai_filtrage(filename);
 if (foo) {
-	fprintf(stderr, "************ %d\n", foo);
+	fprintf(stderr, "====> %d\n", foo);
 	}
 
 return 0;

scripts/README.md

@@ -5,13 +5,20 @@ _Attention_, ce ne sont que des exemples, pas forcément adaptés
 
 ## shoot.sh
 
-Front-end de prise de photographies floues
+Front-end de prise de photographies floues. C'est un script assez
+simple à configurer : les valeurs par défaut fonctionnent.
+Il faut juste renseigner l'emplacement de votre `grabviseq`
+en début du script.
 
 ## contrast-test.sh
 
-Démonstrateur d'ajustements de contraste.
+Démonstrateur d'ajustements de contraste. La configuration est
+en dur dans le code.
 
 ## echomix.sh
 
 Comment générer des videos psychotiques avec un peu de bash.
+Ce script est expliqué dans la documentation PDF.
+
+