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 sauter directement à
+Vous avez parfaitement le droit de auter 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. Myrys, punk, toussa\dots}
+\textit{Attention, ça devient un peu gore.}
 
 \subsection{Prérequis}
 
@@ -209,8 +209,6 @@ 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 
@@ -476,8 +474,6 @@ 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		*/
@@ -489,15 +485,6 @@ 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}
@@ -545,13 +532,12 @@ 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. Sinon, ça foire parfois.
+Tous les flags doivent être à zéro.
 
 \subsubsection{Vers/depuis TIFF}\index{TIFF}
 
@@ -563,8 +549,7 @@ To be done\index{XXX}
 
 \subsubsection{Vers FITS}\index{FITS}
 
-Ce format est essentiellement utilisé pour stocker des images
+Essentiellement des images d'astronomie.
-d'astronomie.
 
 To be done\index{XXX}
 
@@ -586,9 +571,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 actuellement connues sont : fimg, png, pnm et tiff.
+Les extensions connues sont : fimg, png, pnm et tiff.
 
-To be continued\index{XXX}\dots
+To be continued\index{XXX}
 
 
 \subsection{Effets}\index{sfx}
@@ -609,45 +594,13 @@ 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} ces deux fonctions~:
+Ensuite que je débuggue\index{bug} cette fonction~:
 
 \begin{lstlisting}
 int fimg_lissage_2x2(FloatImg *img);
-int fimg_killborders(FloatImg *img);
 \end{lstlisting}
 
-Bon, oké, ça marche ? Passons à l'tape suivante. 
+To be continued\index{XXX}\dots
-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}
 
 %		----------------------------------
 
@@ -834,8 +787,6 @@ 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}
@@ -846,7 +797,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
@@ -870,7 +821,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}).
@@ -1143,39 +1094,6 @@ 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	95
+#define		FIMG_VERSION	94
 
 /*
  *	in memory descriptor
@@ -80,17 +80,8 @@ 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);
@@ -136,14 +127,12 @@ 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 -pg -no-pie -DDEBUG_LEVEL=0
+COPT = -Wall -fpic -g -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,75 +7,7 @@
 #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;
@@ -87,11 +19,6 @@ 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++) {
@@ -129,11 +56,6 @@ 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++) {
@@ -171,20 +93,4 @@ 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,44 +11,6 @@
 
 /* --------------------------------------------------------------------- */
 
-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,68 +13,14 @@ int		verbosity;
 float		global_fvalue;
 
 /* --------------------------------------------------------------------- */
-int essai_filtrage_3x3(char *infile)
+int essai_filtrage(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, "%s: loading %s\n", __func__, 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);
@@ -89,17 +35,11 @@ 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);
-	sprintf(buffer, "filter%03d.png", idx);
+	foo = fimg_killborders(&fimg);
-	foo = fimg_save_as_png(&fimg, buffer, 0);
+	sprintf(buffer, "filter%03d.pnm", idx);
-	if (verbosity) {
+	foo = fimg_save_as_pnm(&fimg, buffer, 0);
-		fprintf(stderr, "%s %d\n", buffer, foo);
-		}
 	}
 
 fimg_destroy(&fimg);
@@ -114,11 +54,7 @@ int		foo;
 
 if (NULL != infile) {
 	fprintf(stderr, "loading %s\n", infile);
-	foo = fimg_create_from_dump(infile, &fimg);
+	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);
@@ -149,11 +85,7 @@ int		foo;
 
 if (NULL != infile) {
 	fprintf(stderr, "loading %s\n", infile);
-	foo = fimg_create_from_dump(infile, &fimg);
+	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);
@@ -294,19 +226,11 @@ 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, "Filtre 2x2 ====> %d\n", foo);
+	fprintf(stderr, "====> %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 -pg  -no-pie -DDEBUG_LEVEL=0
+COPT = -Wall -fpic -g  -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,31 +144,6 @@ 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,8 +28,7 @@ if (foo) {
 	}
 
 if (verbosity) {
-	fprintf(stderr, "%s: image '%s' is %d x %d  %s\n", 
+	fprintf(stderr, "image '%s' is %d x %d  %s\n",
-				__func__,
 				srcname, infos[0], infos[1],
 				fimg_str_type(infos[2]));
 	}
@@ -46,8 +45,7 @@ if (grisaille) {
 
 foo = fimg_save_as_png(&fimg, dstname, 0);
 if (foo) {
-	fprintf(stderr, "%s: saving as png '%s' -> %d\n", __func__,
+	fprintf(stderr, "saving as png '%s' -> %d\n", dstname, foo);
-					dstname, foo);
 	return -1;
 	}
 

tools/mkfimg.c

@@ -14,7 +14,6 @@ int		verbosity;
 #define		T_GRAY		3
 #define		T_HDEG_A	4
 #define		T_VDEG_A	5
-#define		T_TPAT0		6
 
 typedef struct {
 	int		code;
@@ -28,7 +27,7 @@ Type types[] = {
 	{ T_GRAY,	"grey"			},
 	{ T_HDEG_A,	"hdeg"			},
 	{ T_VDEG_A,	"vdeg"			},
-	{ T_TPAT0,	"tpat0"			},
+
 	{ 0,		NULL			}
 	};
 
@@ -129,7 +128,6 @@ 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);