Zzzzz....

doc/the_floatimg_hack.tex

@@ -77,7 +77,7 @@ IRC de Freenode.
 
 \textbf{Attention !} ce document commence par une bonne rafale
 de technique parfois hardue\footnote{gni?}.
-Vous avez parfaitement le droit de auter directement à
+Vous avez parfaitement le droit de sauter directement à
 la page \pageref{outils} pour quelque chose de plus concret.
 
 % -------------------------------------------------------------------
@@ -194,7 +194,7 @@ lesquels sont décrits en page \pageref{outils}.
 % -------------------------------------------------------------------
 \section{Installation}
 
-\textit{Attention, ça devient un peu gore.}
+\textit{Attention, ça devient un peu gore. Myrys, punk, toussa\dots}
 
 \subsection{Prérequis}
 
@@ -209,6 +209,8 @@ comme \textsc{gnu}/make\index{make}.
 Une connaissance de base de l'utilisation du shell\index{shell}
 et de l'écriture de Makefile's sera un plus.
 
+Il faut aussi savoir où trouver le code.
+
 \subsection{Compilation}
 
 Un script \texttt{build.sh} permet de construire approximativement 
@@ -474,6 +476,8 @@ de pixel flottant.
 \subsection{Géométrie}\index{géométrie}\label{geometrie}
 
 Très prochainement, le retour du blitter\index{blitter}.
+Et pour attendre, un truc improbable, voire même
+inutile.
 
 \begin{lstlisting}
 /*	module funcs/geometry.c		*/
@@ -485,6 +489,15 @@ contenir d'image, et doit être effacé avec un bon
 \texttt{memset(\&result, 0, sizeof(FloatImg));} bien senti.
 Et le résultat est très moyen : il n'y a pas d'interpolation.
 
+\begin{lstlisting}
+/*	module funcs/geometry.c		*/
+int fimg_extract_0(FloatImg *src, FloatImg *dst, int x, int y);
+\end{lstlisting}
+
+Contrairement à la fonction précédente, celle-ci demande absolument une
+image de destination initialisée aux dimensions (largeur et hauteur)
+désirées.
+
 %		----------------------------------
 
 \subsection{Exportation \& Importation}\index{export}\label{export}
@@ -532,12 +545,13 @@ Actuellement, on peut enregistrer uniquement en mode RGB, 8 bits par composante,
 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.
+On peut aussi songer à l'export de    metadatas.
 
 \begin{lstlisting}
 int fimg_save_as_png(FloatImg *src, char *outname, int flags);
 \end{lstlisting}
 
-Tous les flags doivent être à zéro.
+Tous les flags doivent être à zéro. Sinon, ça foire parfois.
 
 \subsubsection{Vers/depuis TIFF}\index{TIFF}
 
@@ -549,7 +563,8 @@ To be done\index{XXX}
 
 \subsubsection{Vers FITS}\index{FITS}
 
-Essentiellement des images d'astronomie.
+Ce format est essentiellement utilisé pour stocker des images
+d'astronomie.
 
 To be done\index{XXX}
 
@@ -571,9 +586,9 @@ La fonction \texttt{int format\_from\_extension(char *fname)} examine un
 nom defichier tel que \texttt{lena.xxx}, et retourne, si la partie
 \texttt{xxx} un éventuel nombre positif, dont les valeurs sont dans floatimg.h
 le valeureux.
-Les extensions connues sont : fimg, png, pnm et tiff.
+Les extensions actuellement connues sont : fimg, png, pnm et tiff.
 
-To be continued\index{XXX}
+To be continued\index{XXX}\dots
 
 
 \subsection{Effets}\index{sfx}
@@ -594,13 +609,45 @@ int fimg_killcolors_b(FloatImg *fimg, float fval);
 
 Pour commencer, il faut que je réfléchisse au traitement
 des bordures des images.
-Ensuite que je débuggue\index{bug} cette fonction~:
+Ensuite que je débuggue\index{bug} ces deux fonctions~:
 
 \begin{lstlisting}
 int fimg_lissage_2x2(FloatImg *img);
+int fimg_killborders(FloatImg *img);
 \end{lstlisting}
 
-To be continued\index{XXX}\dots
+Bon, oké, ça marche ? Passons à l'tape suivante. 
+La convolution avec une matrice 3x3, c'est possible.
+Et pas trop compliqué à faire.
+Bon, il reste le souci avec les bordures, souci qui ne peut
+être que temporaire, mais ésotérique à fixer.
+
+Passons maintenant aux choses sérieuses, et définissons la
+description d'un filtre 3x3. 
+
+\begin{verbatim}
+typedef struct {
+        float                matrix[9];
+        float                mult;
+        float                offset;
+        } FimgFilter3x3;
+\end{verbatim}
+
+L'usage des champs \texttt{mult} et \texttt{offset} n'est pas
+clairement défini. Le prototype de la fonction de filtrage
+non plus, mais assez simpe quand même. Source et destination
+ne peuvent désigner la même image, et le champ \texttt{matrix}
+du filtre doit contenir des valeurs cohérentes.
+
+\begin{verbatim}
+int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
+\end{verbatim}
+
+Comme dans la plupart des cas, la gestion des valeurs négatives
+de pixel est laissé au hasard. Quoique, il doit bien exister
+quelques solutions de contournement : clamping ou shift ?
+
+\textsl{To be continued\index{XXX}\dots}
 
 %		----------------------------------
 
@@ -787,6 +834,8 @@ La véracité mathématique n'est pas garantie. Et n'oubliez pas que
 les valeurs négatives peuvent être la cause de \textsl{glitches}
 de qualitay.
 
+%		-------------------------
+
 \subsection{fimg2png, fimg2pnm, fimg2tiff}
 		\index{fimg2png}\label{fimg2png}
 		\index{fimg2pnm}\label{fimg2pnm}
@@ -797,7 +846,7 @@ vers des choses plus directement utilisables. À condition que le
 code soit écrit et documenté.
 
 D'un autre coté, écrire un greffon d'import/export pour
-Gimp\index{Gimp} ou Imagemagick\index{Imagemagick} ou Krita\index{Krita}
+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
@@ -821,7 +870,7 @@ C'est par ces frottements de techniques ayant du sens que les
 choses seront acquises.
 
 \begin{itemize} 
-\item	Import/export au format \textsc{tiff}\index{tiff}.
+\item	Import/export au format \textsc{tiff}\index{TIFF}.
 \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}).
@@ -1094,6 +1143,39 @@ l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
 ce logiciel doit être pris avec des pincettes. En particulier
 la liste des résolutions disponibles.
 
+% -------------------------------------------------------------------
+\section{À l'extérieur}
+
+
+\subsection{ImageMagick}\index{ImageMagick}
+
+Pour afficher notre format .fimg exotique avec \texttt{display}, vous
+devez mettre ce bout de XML\index{XML} dans le fichier
+\texttt{\$HOME/.magick/delegates.xml}~:
+
+\begin{verbatim}
+<?xml version="1.0" encoding="UTF-8"?>
+<delegatemap>
+  <delegate decode="fimg" command="fimg2png '%i' '%o'"/>
+</delegatemap>
+\end{verbatim}
+
+C'est juste un hack rapide, qui ne fonctionne pas très bien avec
+d'autres commande de IM, comme identify, qui a tendance à
+raconter un peu n'importe quoi... Je compte donc sur le bouquin
+de \textsl{Brunus} pour avancer...
+
+\subsection{Gimp}\index{Gimp}
+
+Mmmmm... Ça semble un peu plus compliqué. D'un autre coté, il
+faut faire ça en \textbf{C}, ce qui ne peut être négatif.
+
+\subsection{Et encore ?}\index{krita}\index{geeqie}
+
+Il y a d'autres logiciels pour lesquels écrire une fonction d'importation
+serait bien~: \textsl{Geeqie}, un visualiseur d'image fort pratique, ou
+\textsl{Krita} qui semble avoir les faveurs de dessinateurs de talent.
+
 % -------------------------------------------------------------------
 \section{Et pour la suite ?}
 

floatimg.h

@@ -2,7 +2,7 @@
  *	floatimg.h
  */
 
-#define		FIMG_VERSION	94
+#define		FIMG_VERSION	95
 
 /*
  *	in memory descriptor
@@ -80,8 +80,17 @@ int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
 int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
 
 
+/*	funcs/filtrage.c		*/
+
+typedef struct {
+	float		matrix[9];
+	float		mult;
+	float		offset;
+	} FimgFilter3x3;
+
 int fimg_killborders(FloatImg *img);
 int fimg_lissage_2x2(FloatImg *img);
+int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
 
 /*	'sfx0' module 			*/
 int fimg_killcolors_a(FloatImg *fimg, float fval);
@@ -127,12 +136,14 @@ void  fimg_mul_cste(FloatImg *fi, float value);
 int   fimg_normalize(FloatImg *fi, double maxima, int notused);
 void  fimg_drand48(FloatImg *fi, float kmul);
 int   fimg_count_negativ(FloatImg *fi);
+int   fimg_clamp_negativ(FloatImg *fi);
 
 /*	various funcs modules		*/
 int   fimg_load_from_png(char *filename, FloatImg *fimg);
 int   fimg_create_from_png(char *filename, FloatImg *fimg);
 int   fimg_save_as_png(FloatImg *src, char *outname, int flags);
 
+int   fimg_test_pattern(FloatImg *fimg, int type, double dval);
 int   fimg_draw_something(FloatImg *fimg);
 
 int parse_WxH(char *str, int *pw, int *ph);

funcs/Makefile

@@ -1,6 +1,6 @@
 #---------------------------------------------------------------
 
-COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
+COPT = -Wall -fpic -g -pg -no-pie -DDEBUG_LEVEL=0
 DEPS = ../floatimg.h Makefile
 OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o	\
 	fimg-libpnm.o rampes.o sfx0.o geometry.o

funcs/filtrage.c

@@ -7,7 +7,75 @@
 #include  "../floatimg.h"
 
 /* -------------------------------------------------------------------- */
-int fimg_lissage_2x2(FloatImg *img)
+/* -------------------------------------------------------------------- */
+/* -------------------------------------------------------------------- */
+int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
+{
+int		x, y, w, h, of;
+float		*pr, *pg, *pb;		/* alias for src pix filds */
+float		*M;			/* alias of filter matrix */
+double		dval;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %p %p)\n", __func__, s, d, filtr);
+#endif
+
+/*	aliasing some vars for cleaner code */
+pr = src->R;	pg = src->G;	pb = src->B;
+w = src->width;	h = src->height;
+M = filtr->matrix;
+
+for (y=1; y < h-1; y++) {
+
+	for (x=1; x < w-1; x++) {
+
+		of = x + (y * w);
+
+	dval =	M[0] * pr[of-(w+1)]	+
+		M[1] * pr[of-w]		+
+		M[2] * pr[of-(w-1)]	+
+		M[3] * pr[of-1]		+
+		M[4] * pr[of]		+
+		M[5] * pr[of+1]		+
+		M[6] * pr[of+(w+1)]	+
+		M[7] * pr[of+w]		+
+		M[8] * pr[of+(w-1)]	;
+
+	dst->R[of] = dval;
+
+	dval =	M[0] * pg[of-(w+1)]	+
+		M[1] * pg[of-w]		+
+		M[2] * pg[of-(w-1)]	+
+		M[3] * pg[of-1]		+
+		M[4] * pg[of]		+
+		M[5] * pg[of+1]		+
+		M[6] * pg[of+(w+1)]	+
+		M[7] * pg[of+w]		+
+		M[8] * pg[of+(w-1)]	;
+
+	dst->G[of] = dval;
+
+	dval =	M[0] * pb[of-(w+1)]	+
+		M[1] * pb[of-w]		+
+		M[2] * pb[of-(w-1)]	+
+		M[3] * pb[of-1]		+
+		M[4] * pb[of]		+
+		M[5] * pb[of+1]		+
+		M[6] * pb[of+(w+1)]	+
+		M[7] * pb[of+w]		+
+		M[8] * pb[of+(w-1)]	;
+
+	dst->B[of] = dval;
+	}
+}
+
+return -1;
+}
+/* -------------------------------------------------------------------- */
+/*
+ *	this is the more shifting hack on the block.
+ */
+static int fimg_lissage_2x2_a(FloatImg *img)
 {
 int		x, y, offset;
 float		cr, cg, cb;
@@ -19,6 +87,11 @@ fprintf(stderr,"     type %d size %dx%d\n", img->type,
 					img->width, img->height);
 #endif
 
+if (img->type != FIMG_TYPE_RGB) {
+	fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
+	return -99;
+	}
+
 pr = img->R;	pg = img->G;	pb = img->B;
 
 for (y=1; y < img->height-1; y++) {
@@ -56,6 +129,11 @@ fprintf(stderr,"     type %d size %dx%d\n", img->type,
 					img->width, img->height);
 #endif
 
+if (img->type != FIMG_TYPE_RGB) {
+	fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
+	return -99;
+	}
+
 h = img->height;	w = img->width;
 
 for (idx=0; idx<h; idx++) {
@@ -93,4 +171,20 @@ for (idx=0; idx<w; idx++) {
 return -1;
 }
 /* -------------------------------------------------------------------- */
+int fimg_lissage_2x2(FloatImg *img)
+{
+int		foo;
+
+foo = fimg_lissage_2x2_a(img);
+if (foo) {
+	fprintf(stderr, "%s: fail %d\n", __func__, foo);
+	return foo;
+	}
+
+/* XXX */
+fimg_killborders(img);
+
+return foo;
+}
+/* -------------------------------------------------------------------- */
 

funcs/misc-plots.c

@@ -11,6 +11,44 @@
 
 /* --------------------------------------------------------------------- */
 
+int fimg_test_pattern(FloatImg *fimg, int type, double dval)
+{
+int		nio;
+int		x, y;
+float		fr, fg, fb, val;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d %g )\n", __func__, fimg, type, dval);
+#endif
+
+if (fimg->type != FIMG_TYPE_RGB) {
+	fprintf(stderr, "%s need an rgb pic\n", __func__);
+	return -6;
+	}
+
+/* rampe de primaires dans le quart du haut */
+val = (float)dval;
+for (x=0; x<fimg->width; x++) {
+	nio = x / (fimg->width / 8);
+	switch(nio) {
+		case 0:	fr = 0.0, fg = 0.0, fb = 0.0;	break;
+		case 1:	fr = val, fg = 0.0, fb = 0.0;	break;
+		case 2:	fr = 0.0, fg = val, fb = 0.0;	break;
+		case 3:	fr = val, fg = val, fb = 0.0;	break;
+		case 4:	fr = 0.0, fg = 0.0, fb = val;	break;
+		case 5:	fr = val, fg = 0.0, fb = val;	break;
+		case 6:	fr = 0.0, fg = val, fb = val;	break;
+		case 7:	fr = val, fg = val, fb = val;	break;
+		default:
+			abort();			break;
+		}
+	for (y=0; y<fimg->height/4; y++)
+			fimg_plot_rgb(fimg, x, y, fr, fg, fb);
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
 int fimg_draw_something(FloatImg *fimg)
 {
 int	x, y;

funcs/t.c

@@ -13,14 +13,68 @@ int		verbosity;
 float		global_fvalue;
 
 /* --------------------------------------------------------------------- */
-int essai_filtrage(char *infile)
+int essai_filtrage_3x3(char *infile)
+{
+FloatImg	src, dst;
+int		foo, idx;
+char		buffer[100];
+
+FimgFilter3x3	filter_a =  {
+
+	{	1.0,	1.0,	1.0,
+		1.0,   -3.0,	1.0,
+		1.0,	1.0,	1.0 },
+		8.0, 0.0
+
+	};
+
+FimgFilter3x3	filter_b =  {
+
+	{	-2.0,	-1.0,	0.0,
+		-1.0,    3.0,	1.0,
+		0.0,	 1.0,	2.0 },
+		8.0, 0.0
+
+	};
+
+if (NULL != infile) {
+	fprintf(stderr, "%s: loading %s\n", __func__, infile);
+	foo = fimg_create_from_dump(infile, &src);
+	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(&src, 640, 480, FIMG_TYPE_RGB);
+	fimg_test_pattern(&src, 0, 255.0);
+	fimg_save_as_png(&src, "test.png", 0);
+	}
+
+foo = fimg_clone(&src, &dst, 0);
+
+fimg_filter_3x3(&src, &dst, &filter_b);
+foo = fimg_clamp_negativ(&dst);
+if (foo) {
+	fprintf(stderr, "clamped %d negativ pixels\n", foo);
+	}
+foo = fimg_save_as_png(&dst, "f3x3.png", 0);
+foo = fimg_save_as_pnm(&dst, "f3x3.pnm", 0);
+
+fimg_destroy(&src);	fimg_destroy(&dst);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+int essai_filtrage_2x2(char *infile)
 {
 FloatImg	fimg;
 int		foo, idx;
 char		buffer[100];
 
 if (NULL != infile) {
-	fprintf(stderr, "loading %s\n", infile);
+	fprintf(stderr, "%s: loading %s\n", __func__, infile);
 	foo = fimg_create_from_dump(infile, &fimg);
 	if (foo) {
 		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
@@ -35,11 +89,17 @@ else	{
 
 foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);
 
-for (idx=0; idx<20; idx++) {
+/*
+ *	running multiple filters so you can
+ *	watch the up-left shift :)
+ */
+for (idx=0; idx<5; idx++) {
 	foo = fimg_lissage_2x2(&fimg);
-	foo = fimg_killborders(&fimg);
+	sprintf(buffer, "filter%03d.png", idx);
-	sprintf(buffer, "filter%03d.pnm", idx);
+	foo = fimg_save_as_png(&fimg, buffer, 0);
-	foo = fimg_save_as_pnm(&fimg, buffer, 0);
+	if (verbosity) {
+		fprintf(stderr, "%s %d\n", buffer, foo);
+		}
 	}
 
 fimg_destroy(&fimg);
@@ -54,7 +114,11 @@ int		foo;
 
 if (NULL != infile) {
 	fprintf(stderr, "loading %s\n", infile);
-	fimg_create_from_dump(infile, &fimg);
+	foo = fimg_create_from_dump(infile, &fimg);
+	if (foo) {
+		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
+		return foo;
+		}
 	}
 else	{
 	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
@@ -85,7 +149,11 @@ int		foo;
 
 if (NULL != infile) {
 	fprintf(stderr, "loading %s\n", infile);
-	fimg_create_from_dump(infile, &fimg);
+	foo = fimg_create_from_dump(infile, &fimg);
+	if (foo) {
+		fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
+		return foo;
+		}
 	}
 else	{
 	fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
@@ -226,11 +294,19 @@ fprintf(stderr, "argc %d   optind %d\n", argc, optind);
 filename = NULL;
 if (1 == argc-optind)	filename = argv[optind];
 
-foo = essai_filtrage(filename);
+/*
+foo = essai_filtrage_2x2(filename);
 if (foo) {
-	fprintf(stderr, "====> %d\n", foo);
+	fprintf(stderr, "Filtre 2x2 ====> %d\n", foo);
+	}
+*/
+
+foo = essai_filtrage_3x3(filename);
+if (foo) {
+	fprintf(stderr, "Filtre 3x3 ====> %d\n", foo);
 	}
 
+fprintf(stderr, "++++++++++++++ end of pid %d\n", getpid());
 return 0;
 }
 /* --------------------------------------------------------------------- */

lib/Makefile

@@ -2,7 +2,7 @@
 #	building the base library
 #
 
-COPT = -Wall -fpic -g  -no-pie -DDEBUG_LEVEL=0
+COPT = -Wall -fpic -g -pg  -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		\

lib/fimg-math.c

@@ -144,6 +144,31 @@ for (idx=0; idx<nbre; idx++) {
 	if (fi->R[idx] < 0.0) count++;
 	}
 
+return count;
+}
+/* ---------------------------------------------------------------- */
+/* nouveau 29 fevrier 2020 */
+int fimg_clamp_negativ(FloatImg *fi)
+{
+int		nbre, idx;
+int		count;
+
+if (fi->type != FIMG_TYPE_RGB) {
+	fprintf(stderr, "%s : type %d invalide\n",
+				__func__, fi->type);
+	return -1;
+	}
+
+nbre = fi->width * fi->height * fi->type;
+
+count = 0;
+for (idx=0; idx<nbre; idx++) {
+	if (fi->R[idx] < 0.0) {
+		fi->R[idx] = 0.0;
+		count++;
+		}
+	}
+
 return count;
 }
 /* ---------------------------------------------------------------- */

tools/fimg2png.c

@@ -28,7 +28,8 @@ if (foo) {
 	}
 
 if (verbosity) {
-	fprintf(stderr, "image '%s' is %d x %d  %s\n",
+	fprintf(stderr, "%s: image '%s' is %d x %d  %s\n", 
+				__func__,
 				srcname, infos[0], infos[1],
 				fimg_str_type(infos[2]));
 	}
@@ -45,7 +46,8 @@ if (grisaille) {
 
 foo = fimg_save_as_png(&fimg, dstname, 0);
 if (foo) {
-	fprintf(stderr, "saving as png '%s' -> %d\n", dstname, foo);
+	fprintf(stderr, "%s: saving as png '%s' -> %d\n", __func__,
+					dstname, foo);
 	return -1;
 	}
 

tools/mkfimg.c

@@ -14,6 +14,7 @@ int		verbosity;
 #define		T_GRAY		3
 #define		T_HDEG_A	4
 #define		T_VDEG_A	5
+#define		T_TPAT0		6
 
 typedef struct {
 	int		code;
@@ -27,7 +28,7 @@ Type types[] = {
 	{ T_GRAY,	"grey"			},
 	{ T_HDEG_A,	"hdeg"			},
 	{ T_VDEG_A,	"vdeg"			},
-
+	{ T_TPAT0,	"tpat0"			},
 	{ 0,		NULL			}
 	};
 
@@ -128,6 +129,7 @@ switch(type) {
 				break;
 	case T_HDEG_A:		fimg_hdeg_a(&fimg, 1.0);	break;
 	case T_VDEG_A:		fimg_vdeg_a(&fimg, 1.0);	break;
+	case T_TPAT0:		fimg_test_pattern(&fimg, 0, fvalue); break;
 	}
 
 foo = fimg_dump_to_file(&fimg, fname, 0);