seekin the holy gral of pipedeprod

Fonderie/fifo.c

@@ -79,7 +79,7 @@ return 0;
 /* -------------------------------------------------------------- */
 /*			called by 'fonderie.c'
  */
-int export_fifo(char *fname, int step)
+int export_fifo(char *fname, int notused)
 {
 int		foo, type;
 
@@ -136,13 +136,18 @@ if (verbosity > 2) fprintf(stderr, "%s : next slot %d\n",
 return 0;
 }
 /* -------------------------------------------------------------- */
-int create_fifo(int nbslot, int w, int h, int t)
+/*
+ *	this function must have a lot of new  parameters,
+ *	-- filetype of exported pictures...
+ */
+
+int create_fifo(int nbslot, int w, int h, int imgtype)
 {
 int		foo, idx;
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %d  %dx%d  %d )\n", __func__,
-			nbslot, w, h, t);
+			nbslot, w, h, imgtype);
 #endif
 
 memset(&g_fifo, 0, sizeof(A_Fifo));
@@ -152,17 +157,32 @@ g_fifo.nbslots = nbslot;
 g_fifo.slots = calloc(nbslot, sizeof(FloatImg));
 if (NULL==g_fifo.slots)	abort();
 for (idx=0; idx<nbslot; idx++) {
-	foo = fimg_create(&g_fifo.slots[idx], w, h, t);
+	foo = fimg_create(&g_fifo.slots[idx], w, h, imgtype);
 	if (foo) {
 		fprintf(stderr, "%s idx %d err%d\n", __func__, idx, foo);
 		return foo;
 		}
 	fimg_clear(&g_fifo.slots[idx]);
 	}
-foo = fimg_create(&g_fifo.total, w, h, t);
+foo = fimg_create(&g_fifo.total, w, h, imgtype);
 g_fifo.next = 0;
 g_fifo.magic = MAGIC_FIFO;
 
 return 0;
 }
 /* -------------------------------------------------------------- */
+/*
+ *	omfg ! I've write a setter !
+ */
+int set_fifo_output_format(int filetype)
+{
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, filetype);
+#endif
+
+g_fifo.export_type = filetype;
+
+return -1;
+}
+

Fonderie/fifo.h

@@ -1,15 +1,21 @@
 /*
- *		Machine qui fait des fils flous
+ *		Machine qui fait des fils flous par la
+ *		méthode de la moyenne mobile.
  */
 /* -------------------------------------------------------------- */
 
 typedef struct {
 	unsigned long	magic;
 	int		nbslots;	/* how many pics used ? */
+
 	FloatImg	total;		/* computing workspace */
 	FloatImg	wspace;		/* computing workspace */
+
 	FloatImg	*slots;		/* circular buffer */
+
 	int		next;		/* incremented with modulo */
+
+	int		export_type;	/* fimg/png/pnm/... */
 	} A_Fifo;
 
 #define MAGIC_FIFO	0xabcd9876
@@ -29,11 +35,13 @@ typedef struct {
 
 /* -------------------------------------------------------------- */
 
-int export_fifo(char *fname, int step);
+int create_fifo(int nbslot, int w, int h, int t);
+int set_fifo_output_format(int filetype);
+
+int export_fifo(char *fname, int notused);
 
 int insert_picture(FloatImg *src);
 
-int create_fifo(int nbslot, int w, int h, int t);
 
 /* -------------------------------------------------------------- */
 /*

Fonderie/fonderie.c

@@ -77,7 +77,7 @@ return 0;
 /* -------------------------------------------------------------- */
 
 int demarre_la_machine(char *pattern, char *outdir, int szfifo,
-					int step, int blk)
+					int outfmt, int blk)
 {
 int			foo, idx, width, height;
 glob_t			globbuf;
@@ -92,8 +92,6 @@ fprintf(stderr, "\n>>> %s ( '%s' -> '%s'  %d )\n", __func__,
 			pattern, outdir, szfifo);
 #endif
 
-if (1 != step) fprintf(stderr, "\tstep is %d\n", step);
-
 (void)fimg_timer_set(0);
 
 memset(&globbuf, 0, sizeof(glob_t));
@@ -197,7 +195,7 @@ int		foo, opt;
 int		fifosize = 10;
 char		*in_pattern = "capture/?????.fimg";
 char		*out_dir = "p8";
-int		steps = 1;
+int		outfmt = FILE_TYPE_PNG;
 int		blanks = 20;
 char		*InFchain  = "none";
 char		*OutFchain = "none";
@@ -206,7 +204,7 @@ fprintf(stderr, "*** %s\n\tcompiled %s, %s, pid %d\n",
 			argv[0], __DATE__, __TIME__, getpid());
 fimg_print_version(2);
 
-while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:s:T:vw:x:")) != -1) {
+while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
 	switch(opt) {
 		case 'E':	InFchain = optarg;		break;
 		case 'F':	OutFchain = optarg;		break;
@@ -227,8 +225,6 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:s:T:vw:x:")) != -1) {
 				break;
 		case 'v':	verbosity++;
 				break;
-		case 's':	steps = atoi(optarg);
-				break;
 		}
 	}
 
@@ -256,7 +252,7 @@ if (verbosity) {
 	fprintf(stderr, ".\n");
 	}
 
-foo = demarre_la_machine(in_pattern, out_dir, fifosize, steps, blanks);
+foo = demarre_la_machine(in_pattern, out_dir, fifosize, outfmt, blanks);
 
 fprintf(stderr, "retour du big-run de la machine -> %d\n", foo);
 

Fonderie/metriques.c

@@ -85,6 +85,10 @@ FloatImg	image;
 int		foo;
 float		fval;
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p %d )\n", __func__, fname, where, mode);
+#endif
+
 foo = fimg_create_from_dump(fname, &image);
 if (foo) {
 	fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fname);

Fonderie/single.c

@@ -23,6 +23,7 @@
 static int		nextpng, counter;
 static char		*destination;
 static int		chainfilter;
+static int		outtype;
 
 /*		and the classic global var			*/
 extern int		verbosity;
@@ -60,6 +61,7 @@ int single_push_picture(FloatImg *pimg)
 {
 int		foo;
 char		line[1000], buff[100];
+char		*extension = ".png";
 
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p )\n", __func__, pimg);
@@ -71,8 +73,7 @@ if ('/' != line[strlen(line)-1]) {
 	strcat(line, "/");
 	}
 
-// fprintf(stderr, "  destdir = '%s'\n", line);
+sprintf(buff, "%05d.%s", nextpng, extension);
-sprintf(buff, "%05d.png", nextpng);
 strcat(line, buff);
 
 // fprintf(stderr, "writing %p to '%s'\n", pimg, line);

Fonderie/single.h

@@ -1,16 +1,21 @@
 /*
 		SINGLE
 	experimental and/or testing code, do not use in
-	production.
+	serious production.
 */
 
 /* -------------------------------------------------------------- */
-
+/*
+ *	next:
+ *	dest:
+ *	fxchain:
+ *	outfmt: see floatimg.h for FILE_TYPE_XXX constants
+ */
 int single_init(int next, char *dest, int fxchain, int outfmt);
+
 int single_push_picture(FloatImg *pimg);
 
 int single_print_state(char *title, int k);
 
 /* -------------------------------------------------------------- */
-/* -------------------------------------------------------------- */
 

Fonderie/singlepass.c

@@ -142,7 +142,7 @@ int		foo, opt;
 char		*filterchain =   "none";
 char		*globbing    =   "./capture/?????.fimg";
 char		*outdir      =   "./p8";
-char		*outtype     =   ".png";
+// char		*outtype     =   ".png";
 int		do_xper = 0;
 
 fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
@@ -189,10 +189,11 @@ if (verbosity) {
 	fprintf(stderr, "\tinput glob        %s\n", globbing);
 	fprintf(stderr, "\tfilter chain      %s\n", filterchain);
 	fprintf(stderr, "\toutput dir        %s\n", outdir);
+	// fprintf(stderr, "\toutput type       %s\n", outtype);
 	fprintf(stderr, "\tdo xper           %d\n", do_xper);
 	}
 
-foo = run_the_singlepass(globbing, outdir, FILTERS, -1);
+foo = run_the_singlepass(globbing, outdir, FILTERS, FILE_TYPE_PNG);
 fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
 
 return 0;

Global.makefile

@@ -0,0 +1,6 @@
+
+#
+#	This file is the 'grandmasta' of the compilation process.
+#			for now, this is juste a wip idea.
+#
+

doc/the_floatimg_hack.tex

@@ -44,15 +44,15 @@
 \newcommand{\interparagraphe { \vspace{60pt} } }
 
 % -------------------------------------------------------------------
-\title{Floating images processing}
+\title{Floating images processing (for fun and profit ?)}
 \author{tTh}
 
 \begin{document}
 \maketitle
 
-\section*{Image flottante ?}
+\section*{Une image flottante ?}
 
-Mais de quoi parle-t-on exactement ?
+\textsl{Mais de quoi parle-t-on exactement ?}
 
 % XXX XXX XXX\vspace{1em}
 
@@ -120,7 +120,9 @@ quelques milliers d'images standard à 256 niveaux, sans trop avoir
 
 \subsection{Dynamique}\index{dynamique}
 
-Dynamique, précision et \textsl{macheps} ?
+Dynamique, précision et \textsl{macheps} ? Peu de gens connaissent
+la fourbitude des calculs en virgule flottante avec les ordinateurs.
+Moi-même compris.
 
 \subsection{Pixel négatif ?}
 
@@ -145,7 +147,7 @@ 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.
-Enfin, non, il y a déja longtemps, avant la pandémie.
+Enfin, non, il y a déja longtemps, avant la grande pandémie.
 
 Tout d'abord, nous devons déclarer et garnir quelques variables
 pour gérer la machinerie interne.
@@ -194,22 +196,26 @@ mean values:
 max value       0.000000
 \end{verbatim}
 
-Nous avons donc sous la main une mécanique qui ne demande qu'à
+Nous avons donc sous la main un ensemble d'outils mécaniques qui ne demande
-faire des trucs futiles et des images qui clignotent.
+qu'à faire des trucs futiles et des images qui clignotent.
+Avec un bon script bash, il y a déja de quoi faire.
 La suite vers la page \pageref{codaz}. 
 
 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,
-lesquels sont décrits en page \pageref{outils}.
+lesquels sont approximativement décrits en page \pageref{outils}.
 
 % ===================================================================
 \section{Installation}
 
 Sauf indications contraires, ces instructions se réfèrent à
-une distribution Debian\index{Debian} récente, mais ça marche
+une distribution Debian\index{Debian} récente (amd64 et x86),
-quasiment pareil avec Fedora\index{Fedora}.
+mais ça marche quasiment pareil avec Fedora\index{Fedora} 64,
-\textit{Attention, ça devient un peu gore\dots}
+et
+probablement Raspbian\index{Raspbian}, modulo les éventuels
+soucis de boutisme.
+\textit{Attention, ça va devenir un peu gore\dots}
 
 \subsection{Prérequis}
 
@@ -234,7 +240,10 @@ Il faut aussi savoir où trouver le code.
 
 \subsection{Compilation}
 
-Un script \texttt{build.sh} permet de construire approximativement 
+La première chose à faire est d'aller regarder le contenu du fichier
+\texttt{Global.makefile} à la racine du projet. Il contient des
+informations pertinentes pour la suite des choses.
+Ensuite, un script \texttt{build.sh} permet de construire approximativement 
 le bouzin. Il est loin d'être parfait\footnote{Il doit être possible
 de faire un Makefile récursif, mais\dots}.
 Dans chacun des répertoires à traiter, ce script devrait trouver
@@ -271,11 +280,12 @@ contenant un certain nombre de définition de structures, de macros,
 de constantes\footnote{À l'ancienne, via le pré-processeur} 
 et les prototypes des fonctions utilisables par vos logiciels.
 
-Au niveau du code source, ces fonctions sont approximativement
+Au niveau du code source, ces fonctions sont très 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 indécement arbitraire.
+D'autant plus qu'il y a aussi un répertoire nommé « experiemental ».
 
 \subsection{Structures, macros\dots}
 
@@ -305,7 +315,7 @@ Le troisième est le type d'image : pour le moment, il y en a % trois
 un certain nombre
 qui sont définis\footnote{et plus ou moins bien gérés\dots} :
 gris, rgb et rgba/rgbz\index{rgba}\index{rgbz}.
-Les constantes adéquates sont dans \texttt{floatimg.h}
+Les constantes adéquates sont déclarées dans \texttt{floatimg.h}~:
 
 \begin{lstlisting}
 #define FIMG_TYPE_GRAY              1
@@ -347,7 +357,7 @@ un affichage plus détaillé. Ça peut parfois aider.
 Une bonne partie des fonctions que nous allons voir est indéterministe.
 Ce qui veut dire, en langage de tous les soirs, que ça risque de ne
 pas être la même chose dans l'avenir. Mais après tout, ce n'est
-encore qu'un concept en devenir, n'est-ce pas ?
+encore qu'un concept en devenir, n'est-il pas ?
 
 %		----------------------------------
 
@@ -355,8 +365,9 @@ encore qu'un concept en devenir, n'est-ce pas ?
 
 La première chose que nous devons absolument voir est la gestion
 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 ?}.
+ce qui est un sujet parfois délicat\footnote{GC or not GC ?} parce que
-Elle est donc faite, à la base, par ces deux fonctions~:
+les pixels sont précieux et doivent être bien rangés.
+Cette gestion est donc faite, à la base, par ces deux fonctions~:
 
 \begin{lstlisting}
 int fimg_create(FloatImg *fimg, int w, int h, int type);
@@ -365,7 +376,8 @@ int fimg_destroy(FloatImg *fimg);
 
 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
-la forme \emph{peut} varier.
+la forme \emph{peut} varier, mais qu'il convient de mettre à zéro
+avant le moindre usage\footnote{\texttt{man 3 memset}}.
 Certains membres de cette structure sont
 documentés dans ce document, et les autres sont dangereux à
 toucher. Les types d'images actuellement gérés sont les trois grands
@@ -382,10 +394,10 @@ int fimg_images_not_compatible(FloatImg *a, FloatImg *b);
 \end{lstlisting}
 
 
-C'est bien beau d'être enfin résident en mémoire centrale, mais
+C'est bien beau d'être enfin une image résidente en mémoire centrale, mais
 pouvoir aussi exister à long terme en étant stocké dans la matrice
-est tout aussi pertinent. Il y a deux opérations qui supportent le
+est tout aussi pertinent.
-reste des transits ram/ps.
+Il y a deux opérations qui supportent le reste des transits ram/ps.
 Le format des fichiers est décrit page \pageref{formatfimg}.
 
 \begin{lstlisting}
@@ -581,9 +593,13 @@ typedef struct {
 la valeur maximale, la date de création, une longueur d'onde,
 et bien plus encore.
 
-Le champ \texttt{magic[8]} doit contenir une valeur magique.
+Le champ \texttt{magic[8]} doit contenir une valeur magique~:
+les quatre premier octets doivent contenir les quatre caractères
+\texttt{'FIMG'}, et les quatre dernier doivent être à 0.
 Le champ \texttt{t} (le type de l'image) doit avoir les trois octets
-de poids fort à 0.
+de poids fort à 0. Vous trouverez les constantes de type dans le
+fichier \texttt{floatimg.h}, et quelques informations
+(non-)essentielles.
 
 %		----------------------------------
 
@@ -714,11 +730,14 @@ int fimg_colors_mixer_a(FloatImg *fimg, float fval);
 
 Un \textsl{glitch} peut-il être classé dans la catégorie des effets
 spéciaux ou non ? \textsc{Hmha}, non. un fx est paramétrable
-et surtout répétitif. Un glitch est quasiment souvbent un phénomène
+et surtout répétitif. Un glitch est quasiment souvent un phénomène
 aléatoire\index{drand48} et tout aussi paramétrable.
 
 J'ai commencé à étudier ces objets étranges quand j'ai commencé
-sur l'interpolator\index{interpolator} à l'automne 2020.
+à travailler sur l'interpolator\index{interpolator} à l'automne 2020.
+Hélas, j'ai vite réalisé que c'était assez délicat.
+Pour ce genre de \textsl{usecase}, le numérique est pitoyable si on
+le compare au \textsc{Betamax}\index{Betamax}.
 
 %		----------------------------------
 
@@ -809,12 +828,12 @@ return 0;
 
 Je vous laisse imaginer les dégats que peut faire cette 
 fonction en utilisation réelle. Mieux, je vous propose
-d'essayer par vous-même.
+d'essayer par vous-même, vous allez voir, c'est assez créatif.
 En particulier tout le reste du code qui suppose qu'un pixel
 ne peut \textbf{pas} être négatif va peut-être exploser de rire.
 Vous pouvez aussi remarquer qu'il n'y a pas de controle
 de cohérence sur les dimensions des deux images, malgré l'existence
-de fonctions prévues à cet effet..
+de fonctions prévues à cet effet\dots
 
 
 % ===================================================================
@@ -852,7 +871,7 @@ Usage:  mkfimg [options]  quux.fimg width height
 
 La plupart des types d'image générée prennent un paramètre flottant qui
 devra être donné avec l'option \texttt{-k F.F} avec une valeur par défaut
-à $1.0$.
+à $1.0$, ce qui n'est pas toujours une bonne valeur.
 
 \begin{description}	\index{XXX}
 \item [black/gray/grey:] efface avec 0.0 (black) ou avec la valeur
@@ -991,10 +1010,10 @@ logiciel aux calendes grecques, voire même plus tard.
 \subsection{cumulfimgs}\index{cumulfimgs}\label{cumulfimgs}
 
 Cet outil accumule\index{cumul} une quantité d'images flottantes
-(même taille et même type) afin d'obtenir
+(de même taille et de même type) afin d'obtenir
-un flou de meilleure qualité. Aucune mise à l'échelle n'etant
+un flou temporel de meilleure qualité. Aucune mise à l'échelle n'etant
-effctuée, les pixels de sortie peuvent atteindre des valeurs
+effectuée, les pixels de sortie peuvent atteindre des valeurs
-considérables\footnote{Prévoir une gestion des \textsf{overflows} ?}
+considérables\footnote{Faut-il prévoir une gestion des \textsf{overflows} ?}
 
 \begin{verbatim}
 tth@delirium:~/Devel/FloatImg/tools$ ./cumulfimgs -h
@@ -1009,6 +1028,74 @@ cumulator options :
 Le nom par défaut du fichier résultant est \texttt{out.fimg}.
 L'exportation « multiformat » est pour bientôt.
 
+% ===================================================================
+\section{Debug}\index{Debug}
+
+\textit{Et quand plus rien ne fonctionne normalement ?}
+
+Ayant une attirance marquée pour la méthode de développement dite
+de \textsl{larache}, que je pratique intensément, j'ai quand même
+besoin de m'équiper de quelques garde-fous. Avec l'expérience, j'ai
+découvert quelques méthodes bien utile quand on est à court de
+poudre verte.
+
+\subsection{À la compilation}
+
+Première de cordée, la méthode \texttt{DEBUG\_LEVEL}\index{DEBUG\_LEVEL}.
+Elle me sert
+essentiellement à tracer les appels de fonctions, et les paramètres
+qu'elles reçoivent. Ça fait vraiment partie de la création
+des \textsl{boiler-plates}.
+C'est une valeur numérique entière définie dans chaque
+\texttt{Makefile}\index{Makefile}
+qui sera ensuite utilisée
+par le préprocesseur afin de rajouter ce genre de code dans l'exécutable~:
+
+\begin{verbatim}
+int fimg_export_picture(FloatImg *pic, char *fname, int flags)
+{
+int		filetype, foo;
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__, pic, fname, flags);
+#endif
+...
+\end{verbatim}
+
+Le principe est simple, n'est-il pas, alors pourquoi s'en priver ?
+Bien entendu, la même constante peut être utilisée plus agressivement
+avec une condition comme \texttt{\#if DEBUG\_LEVEL > 2} permettant
+de générer encore plus de messages traçants.
+
+Ensuite, pour les cas les plus graves, qui nécessiteront l'utilisation
+du dévermineur \texttt{gdb}\index{gdb}, il y a la directive
+\texttt{MUST\_ABORT} qui est bien plus violente, mais parfois bien
+pratique. Voici le cas classique d'utilisation~:
+
+\begin{verbatim}
+foo = fimg_strange_function(&picture, 13.37);
+if (foo) {
+        fprintf(stderr, "epic fail %d in %s\n", foo, __func__);
+#if MUST_ABORT
+        abort();
+#endif
+...
+\end{verbatim}
+
+À condition d'avoir bien réglé votre ulimit pour la génération d'un coredump,
+vous aurez sous la main un fichier \textsc{core} qui vous permettra
+de, par exemple, remonter la pile d'appel avec la commande \texttt{back} de
+gdb. Mais pour le moment, juste une infime partie du code est instrumentée
+avec ce dispositif.
+
+
+\subsection{À l'exécution}
+
+De l'utilisation des nombres magiques dans la détection des structures
+corrompues par un pointeur ayant perdu le nord\dots
+
+De l'utilisation des variables d'environnement pour transformer des warnings
+en erreurs fatales\dots
+
 % ===================================================================
 \section{TODO}\index{TODO}\label{TODO}\
 		\index{XXX}
@@ -1016,16 +1103,17 @@ L'exportation « multiformat » est pour bientôt.
 Il reste plein de choses à faire pour que ce soit vraiment utilisable,
 surtout dans un contexte artistique à grande porosité.
 C'est par ces frottements de techniques ayant du sens que les
-choses seront acquises.
+choses seront acquises, pour le pire, le meilleur et la
+futilité du monde futur..
 
 \begin{itemize} 
-\item	Import/export au format \textsc{tiff}\index{TIFF}.
+\item	Import/export au format \textsc{tiff}\index{TIFF} à continuer.
 \item	Remplacer le « fait-maison » par \textsc{libnetpnm}\index{pnm}.
 	\textsl{[en cours]}.
 \item	Compléter les traitements mathémathiques (eg le gamma\index{gamma}).
 \item	Formaliser les codes d'erreur. \textbf{Urgent}.
 \item	Faire une passe complète de Valgrind\index{valgrind}.
-\item	Intégrer la fonderie et l'interpolator.
+\item	Intégrer la fonderie, l'interpolator et le singlepass.
 \item	Vérifier le gestion des images mono-canal.
 \end{itemize}
 
@@ -1374,7 +1462,8 @@ foultitude d'effets spéciaux.
 
 \subsection{\textsl{moving average}}
 
-\texttt{./fonderie} : Basé sur la moyenne mobile.
+\texttt{./fonderie} : Basé sur la moyenne mobile, avec une structure de
+fifo\index{fifo} particulièrement mal conçue.
 
 \subsection{Interpolator}\index{interpolator}
 
@@ -1388,8 +1477,11 @@ avec l'option \texttt{-L}\footnote{liste hélas peu machinable.}
 
 \subsection{Déviance}
 
-Là, nous tombons dans la troiD de haut niveau, avec plein de maths
+Là, nous tombons dans de la \textsl{troiD}\index{3d} de haut niveau,
+avec plein de maths compliquées
 à l'intérieur.
+Et surtout quelque chose qui n'est encore qu'une idée abstraite,
+mais il y aura du zbuffer dedans.
 
 % ===================================================================
 
@@ -1409,6 +1501,10 @@ faire des images au bord d'un lac ou dans la campagne de l'Ariège.
 
 % -------------------------------------------------------------------
 
+%                 XXX
+% maintenant, comment faire un index sur trois colonnes ?
+%
+
 \printindex
 
 \end{document}

funcs/Makefile

@@ -1,5 +1,8 @@
 #---------------------------------------------------------------
 
+#		Please, use the 'Gloabl.makefile' system !
+
+
 COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
 DEPS = ../floatimg.h Makefile
 

funcs/t.c

@@ -22,7 +22,7 @@ float		global_fvalue;
 enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
 			Histo, Hsv, Classif, Ctr2x2, Qsortrgb,
 			Displace, ReadPNG, Plasmas, Hilight, OpenEXR,
-			Geometrie  };
+			Geometrie, FileType  };
 typedef struct {
 	char	*name;
 	int	Cmd;
@@ -48,6 +48,7 @@ Command commands[] = {
 	{ "hilight",	Hilight		},
 	{ "openexr",	OpenEXR		},
 	{ "geometrie",	Geometrie,	},
+	{ "filetype",	FileType	},
 	{ NULL,		0		}
 	} ;
 
@@ -207,6 +208,9 @@ switch(opt) {
 	case Geometrie:
 		foo = essai_geometrie(filename, 0);
 		break;
+	case FileType:
+		foo = essai_detect_type();
+		break;
 	default:
 		fprintf(stderr, "'%s' is a bad command\n", command);
 		exit(1);

funcs/tests.c

@@ -616,22 +616,22 @@ int		foo;
 char		*fname;
 
 foo = format_from_extension(fname="foo.fimg");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 foo = format_from_extension(fname="foo.pnm");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 foo = format_from_extension(fname="foo.png");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 foo = format_from_extension(fname="foo.tiff");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 foo = format_from_extension(fname="foo.fits");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 foo = format_from_extension(fname="foo.xyzzy");
-printf("%-10s %d\n\n", fname, foo);
+printf("%-10s %3d\n", fname, foo);
 
 return 0;
 }
@@ -639,7 +639,7 @@ return 0;
 int essai_mire(char *outname, int notused)
 {
 FloatImg	fimg;
-int		re;
+int		re, foo;
 
 fimg_create(&fimg, 1280, 960, FIMG_TYPE_RGB);
 
@@ -647,9 +647,10 @@ re = fimg_test_pattern(&fimg, 9, 1.0);
 if (re) {
 	fprintf(stderr, "fimg_test_pattern -> %d\n", re);
 	}
-fimg_export_picture(&fimg, "mire.pnm", 0);
+foo = fimg_export_picture(&fimg, "mire.pnm", 0);
+fprintf(stderr, "in %s, export give a %d value\n", __func__, foo);
 
-return -1;
+return 0;
 }
 /* --------------------------------------------------------------------- */
 int essai_rampes(void)

funcs/tests.h

@@ -20,7 +20,7 @@ int fimg_essai_hsv(char *infile);
 int essai_classif(char *infile, char *outfile, float fvalue);
 int essai_contour_2x2(char *filename, char *outfile);
 int essai_geometrie(char *infile, int notused);
-
+int essai_detect_type(void);
 int fimg_essai_histo(FloatImg *src, char *outpic, int k); /* histogram.c */
 int essai_histogramme(char *fname, int k);
 

funcs/utils.c

@@ -49,6 +49,25 @@ if (1 == foo) {
 	*dptr = value;
 	return 1;
 	}
+return -1;
+}
+/* --------------------------------------------------------------------- */
+int file_type_from_name(char *name)
+{
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' )\n", __func__, name);
+#endif
+
+if (!strcasecmp(name, "pnm" ))	return FILE_TYPE_PNM;
+if (!strcasecmp(name, "fimg"))	return FILE_TYPE_FIMG;
+if (!strcasecmp(name, "tga" ))	return FILE_TYPE_TGA;
+if (!strcasecmp(name, "png" ))	return FILE_TYPE_PNG;
+if (!strcasecmp(name, "tiff"))	return FILE_TYPE_TIFF;
+if (!strcasecmp(name, "tif" ))	return FILE_TYPE_TIFF;
+if (!strcasecmp(name, "fits"))	return FILE_TYPE_FITS;
+if (!strcasecmp(name, "exr"))	return FILE_TYPE_EXR;
+
 return -1;
 }
 /* --------------------------------------------------------------------- */
@@ -56,6 +75,10 @@ int format_from_extension(char *fname)
 {
 char		*cptr;
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
+#endif
+
 cptr = rindex(fname, '.');
 if (NULL==cptr) {
 	fprintf(stderr, "No dot in %s\n", fname);
@@ -63,18 +86,28 @@ if (NULL==cptr) {
 	}
 
 #if DEBUG_LEVEL
-fprintf(stderr, "[%s]  -->  [%s]\n", fname, cptr);
+fprintf(stderr, "\t[%s]  -->  [%s]\n", fname, cptr);
 #endif
 
-if (!strcasecmp(cptr, ".pnm" ))	return FILE_TYPE_PNM;
+return file_type_from_name(cptr+1);
-if (!strcasecmp(cptr, ".fimg"))	return FILE_TYPE_FIMG;
+}
-if (!strcasecmp(cptr, ".tga" ))	return FILE_TYPE_TGA;
+/* --------------------------------------------------------------------- */
-if (!strcasecmp(cptr, ".png" ))	return FILE_TYPE_PNG;
+char * extension_from_format(int fmt)
-if (!strcasecmp(cptr, ".tiff"))	return FILE_TYPE_TIFF;
+{
-if (!strcasecmp(cptr, ".tif" ))	return FILE_TYPE_TIFF;
+
-if (!strcasecmp(cptr, ".fits"))	return FILE_TYPE_FITS;
+switch (fmt) {
-if (!strcasecmp(cptr, ".exr"))	return FILE_TYPE_EXR;
+	case FILE_TYPE_FIMG:	return ".fimg";		break;
-
+	case FILE_TYPE_PNM:	return ".pnm";		break;
-return -1;
+	case FILE_TYPE_PNG:	return ".png";		break;
+	case FILE_TYPE_TIFF:	return ".tiff";		break;
+	case FILE_TYPE_FITS:	return ".fits";		break;
+	case FILE_TYPE_TGA:	return ".tga";		break;
+
+	default:
+		fprintf(stderr, "%s: bad %d fmt type\n", __func__, fmt);
+		return NULL;
+	}
+
+return "???";
 }
 /* --------------------------------------------------------------------- */

tools/Makefile

@@ -2,6 +2,8 @@
 #	makefile for floatimg tools
 #	use with caution
 #
+#	PLEASE ! update to the 'Global.makefile' concept !
+#
 
 COPT = -Wall -fpic -g -DDEBUG_LEVEL=0 -lm
 DEPS = ../floatimg.h  ../libfloatimg.a Makefile

tools/fimgfx.c

@@ -31,13 +31,13 @@ Fx fx_list[] = {
 	{ "pow2",		Fx_pow2,	0,	1 },
 	{ "sqrt",		Fx_sqrt,	0,	1 },
 	{ "gray0",		Fx_gray0,	0,	1 },
-	{ "halfsz0",		Fx_halfsz0,	0,	1 },
+//	{ "halfsz0",		Fx_halfsz0,	0,	1 },
-	{ "rot90",		Fx_rot90,	0,	0 },
+//	{ "rot90",		Fx_rot90,	0,	0 },
 	{ "cmixa",		Fx_cmixa,	0,	1 },
 	{ "xper",		Fx_xper,	0,	1 },
 	{ "desat",		Fx_desat,	0,	1 },
 	{ "ctr2x2",		Fx_ctr2x2,	0,	1 },
-	{ "norm",		Fx_norm,	0,	1 },
+//	{ "norm",		Fx_norm,	0,	1 },
 	{ "classtrial",		Fx_classtrial,	0,	1 },
 	{ "binarize",		Fx_binarize,	0,	1 },
 	{ "trinarize",		Fx_trinarize,	0,	1 },
@@ -45,6 +45,14 @@ Fx fx_list[] = {
 	{ NULL,			0,		0,	0 }
 	};
 
+/* --------------------------------------------------------------------- */
+static void list_of_effects(void)
+{
+Fx		*fx;
+for (fx=fx_list; fx->name; fx++) {
+	printf("%s\n", fx->name);
+	}
+}
 /* --------------------------------------------------------------------- */
 int lookup_fxidx(char *txt)
 {
@@ -105,6 +113,7 @@ puts("\tfimgfx [options] <effect> source.fimg resultat.fimg");
 
 puts("options:");
 puts("\t-k N.N\tset the floating value");
+puts("\t-l\tlist effects");
 puts("\t-v\tincrease verbosity");
 
 puts("effects:"); 
@@ -217,9 +226,11 @@ switch (action) {
 
 	}
 
+// foo = fimg_export_picture(&dest, dstfname, 0);
 foo = fimg_dump_to_file(&dest, dstfname, 0);
 if (foo) {
-	fprintf(stderr, "dumping datas to file give us a %d\n", foo);
+	fprintf(stderr, "dumping datas to file '%s' give us a %d\n",
+						dstfname,	foo);
 	return foo;
 	}
 
@@ -240,10 +251,11 @@ char		*operator;
 char		*srcname = "";
 char		*dstname = "out.fimg";
 
-while ((opt = getopt(argc, argv, "hk:v")) != -1) {
+while ((opt = getopt(argc, argv, "hk:lv")) != -1) {
 	switch(opt) {
 		case 'h':	help(0);			break;
 		case 'k':	global_fvalue = atof(optarg);	break;
+		case 'l':	list_of_effects();	exit(0);
 		case 'v':	verbosity++;			break;
 		}
 	}

tools/fx_demo.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+SRC="in.fimg"
+K="0.414"
+TMP="/tmp/foo.fimg"
+
+for fx in $(./fimgfx -l)
+do
+
+	printf "==========   %-12s =========\n" $fx
+
+	outfile=$(printf "/tmp/fx_%s.png" $fx)
+	echo $outfile
+
+	rm $TMP
+	./fimgfx -v -k $K $fx $SRC $TMP
+	if [ $? \!= 0 ] ; then
+		echo error $?
+		exit 1
+	fi
+
+	./fimg2png -v $TMP $outfile
+
+	echo ; sleep 1
+
+done

v4l2/rgb2fimg.c

@@ -25,6 +25,11 @@ static unsigned short		modz;
  */
 if ( d->width != w*2 || d->height != h*2 ) {
 	fprintf(stderr, "%s: dimension error\n", __func__);
+	fprintf(stderr, "\tw = %d   h = %d\n", w, h);
+	fprintf(stderr, "\tdest image is %dx%d\n", d->width, d->height);
+#if MUST_ABORT
+	abort();
+#endif
 	return -2;
 	}