add new ugly tools

.gitignore

@@ -3,6 +3,7 @@
 
 libtthimage.a
 cscope.out
+gmon.out
 
 Lib/foo
 Lib/testtga

Contribs/ExplodeVidz.md

@@ -0,0 +1,16 @@
+
+# Exploding Vidz for fun and profit.
+
+But du jeu : traiter la séquence d'image complète d'une vidéo live,
+sans devoir attendre 107 ans que le job soit fait.
+
+## Current status
+
+- [rgb_decomp.c](rgb_decomp.c) 
+
+## Film at 11.
+
+See you soon.
+
+
+

Contribs/README.md

@@ -0,0 +1,9 @@
+
+# Contributions
+
+Voici une collection informelle de fonctions diverses et variées contribuées
+par moi-même (et peut-être, un jour, d'autres gens...) et qui risquent
+bien de n'être **pas très maintenues**, contrairement au reste du *kluge*.
+
+Nous allons commencer par des fonctions inventées lors d'une *n*-ième session
+du projet [ExplodeVidz](ExplodeVidz.md).

Contribs/rgb_decomp.c

@@ -0,0 +1,87 @@
+
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include  <tthimage.h>
+
+/* -------------------------------------------------------- */
+
+
+/* -------------------------------------------------------- */
+
+int rgb_process_by_filename(char *inf, char *outf)
+{
+Image_Desc	*src, *dst;
+int		foo;
+int		x, y, larg, offs;
+int		r, g, b;
+
+if ( (src=Image_TGA_alloc_load(inf)) == NULL )
+	{
+	fprintf(stderr, "%s: err load %s\n", __func__, inf);
+	exit(5);
+	}
+
+printf("source '%s'   %dx%d\n", inf, src->width, src->height);
+
+if ( (dst=Image_clone(src, 0)) == NULL )
+	{
+	fprintf(stderr, "%s: no mem for image cloning\n", __func__);
+	exit(5);
+	}
+
+Image_clear(dst, 160, 60, 60);
+
+/*
+ *	calcul de la zone à traiter
+ */
+larg = src->width / 3;
+offs = (src->width - larg) / 2;
+printf("largeur  %d   offset   %d\n", larg, offs);
+
+
+for (y=0; y<src->height; y++) {
+	for (x=0; x<larg; x++) {
+
+		Image_getRGB(src, x+offs, y, &r, &g, &b);
+
+		Image_plotRGB(dst, x,          y, r, r, r);
+		Image_plotRGB(dst, x+offs,     y, g, g, g);
+		Image_plotRGB(dst, x+(2*offs), y, b, b, b);
+
+		}
+	}
+
+Image_egalise_cos010(dst, dst, 0);
+
+foo = Image_TGA_save(outf, dst, 0);
+if (foo) {
+	fprintf(stderr, "%s: error %d saving %s\n", __func__, foo, outf);
+	exit(5);
+	}
+
+return 0;
+}
+
+/* -------------------------------------------------------- */
+int main(int argc, char *argv[])
+{
+int	foo;
+
+if (3 != argc)
+	{
+	exit(1);
+	}
+
+foo = rgb_process_by_filename(argv[1], argv[2]);
+if (foo) {
+	fprintf(stderr, "process by filename -> %d\n", foo);
+	}
+
+return 0;
+}
+
+/* -------------------------------------------------------- */

Docs/README.md

@@ -1,4 +1,4 @@
-# libtthimage
+# libtthimage, la doc
 
 Les fichiers [HTML](html/) que vous avez ici sont des versions historiques,
 qui seront peut-être mise à jour au prochain grand refactoring.
@@ -13,11 +13,11 @@ Certaines options de compilation sont dans le fichier de
 [paramètres](../Paramakes.mk) pour les différents fichiers make.
 Je vous conseille de vérifier leurs pertinences, et en particulier
 les options `-p` et `-pg` que j'oublie parfois d'enlever avant
-le _/push_.
+le _push_.
 
 Le script [build.sh](../build.sh)  tente d'automatiser les
 compilations de la bibilothèque, des tests et des outils
-en ligne de commande.
+en ligne de commande. Il est encore loin d'être parfait.
 
 ## Installation
 
@@ -28,4 +28,4 @@ dans le fichier Paramakes.mk !
 
 ## Utilisation
 
-???
+??? *Insérez ici quelques exemples d'utilisation des tools.*

Lib/.gitignore

@@ -1,3 +1,6 @@
 
 *.png
+*.gif
 
+cflow.txt
+reduce.map

Lib/Makefile

@@ -8,7 +8,7 @@ include ../Paramakes.mk
 
 DEPS = ../tthimage.h ../Paramakes.mk Makefile
 
-all:	foo testtga
+all:	foo testtga t_png testbmp
 
 #-----------------------------------------------------------------
 
@@ -64,6 +64,7 @@ extractbits.o:	extractbits.c	$(DEPS)
 filtadapt.o:	filtadapt.c	$(DEPS)
 filtres.o:	filtres.c	$(DEPS)
 falsecolors.o:	falsecolors.c	$(DEPS)
+functions.o:	functions.c	$(DEPS)		# new Aug 15, 2024
 
 gadgrect.o:	gadgrect.c	$(DEPS)
 glitch.o:	glitch.c	$(DEPS)
@@ -153,6 +154,7 @@ OBJECTS =	7seg.o							\
 		doublesz.o drawalpha.o drawing.o drawpatt.o		\
 		effects.o effects2.o effects3.o extractbits.o		\
 		filtadapt.o filtres.o falsecolors.o			\
+		functions.o						\
 		gadgrect.o glitch.o gradient.o				\
 		halfsize.o						\
 		image.o	imprime.o					\
@@ -178,6 +180,7 @@ OBJECTS =	7seg.o							\
 		warp0.o warp1.o warp2.o					\
 		zoom.o
 
+# build the static library
 ../libtthimage.a: 	$(OBJECTS)
 	$(AR) 	rs $@ $?
 	$(RANLIB)   $@

Lib/README.md

@@ -1,8 +1,9 @@
-# The tTh image processind library
+# The tTh image processing library
 
 Ugly software born around 1995 on a MS-Dos 286 computer.
-
+Look at the [`Makefile`](Makefile) for no more explanations.
-Look at the `Makefile` for no more explanations.
+More pertinent informations can be found in
+[`tthimage.h`](../tthimage.h).
 
 
 ## Text primitives

Lib/col4bits.c

@@ -51,13 +51,13 @@ static int compare_teinte(struct elem *p1, struct elem *p2)
 {
 int	r1, g1, b1, r2, b2, g2;
 
-r1 = (( (p1->rgb) >>8)&0xf)<<4; 
+r1 = (( (p1->rgb) >>8)&0xf)	<<4; 
-g1 = (( (p1->rgb) >>4)&0xf)<<4; 
+g1 = (( (p1->rgb) >>4)&0xf)	<<4; 
-b1 = ( (p1->rgb) &0xf)<<4;
+b1 = ( (p1->rgb) &0xf)		<<4;
 
-r2 = (( (p2->rgb) >>8)&0xf)<<4; 
+r2 = (( (p2->rgb) >>8)&0xf)	<<4; 
-g2 = (( (p2->rgb) >>4)&0xf)<<4; 
+g2 = (( (p2->rgb) >>4)&0xf)	<<4; 
-b2 = ( (p2->rgb) &0xf)<<4;
+b2 = ( (p2->rgb) &0xf)		<<4;
 
 /* printf("%8d %8d\n", p1->compte, p2->compte);
  return (p1->rgb - p2->rgb); */
@@ -66,7 +66,9 @@ return ( (r1+g1+b1) - (r2+g2+b2) );
 }
 
 /*::------------------------------------------------------------------::*/
-
+/*
+ *				XXX please explain parameters usage !
+ */
 #define TAILLE	(1<<12)
 int Image_calc_Map_4bits(Image_Desc *img, RGB_map *map, int nbre)
 {
@@ -80,13 +82,13 @@ fprintf(stderr, "  Calc map 4 bits: nbre = %d\n", nbre);
 #endif
 
 if ( (nbre<1) || (nbre>255) ) {
-	fprintf(stderr, "Calc map 4 bits: nbre %d out of range\n", nbre);
+	fprintf(stderr, "%s: nbre %d out of range\n", __func__, nbre);
 	return BAD_COLOR_NUMBER;
 	}
 
 surface = img->width * img->height;
 #if DEBUG_LEVEL
-fprintf(stderr, "  calc Map 4 bits: surface de l'image = %ld pixels\n", surface);
+fprintf(stderr, "%s: surface de l'image = %ld pixels\n", __func__, surface);
 #endif
 
 for (x=0; x<TAILLE; x++) {
@@ -112,7 +114,7 @@ for (x=0; x<img->width; x++) {
         }
     }
 #if DEBUG_LEVEL
-fprintf(stderr, "  Map4bits: compte maximum     = %ld\n", maxi);
+fprintf(stderr, "%s: compte maximum     = %ld\n", __func__, maxi);
 #endif
 
 /*
@@ -123,7 +125,7 @@ qsort(elems, TAILLE, sizeof(struct elem), compare_compteur);
 
 /*
  *	trier la palette, certe, mais dans quel ordre ?
-  *     28 Jan 2002: why ?
+ *	28 Jan 2002: why ?
  */
 qsort(elems, nbre, sizeof(struct elem), compare_teinte);
 

Lib/col_reduc.c

@@ -8,6 +8,8 @@
 
 #include  "../tthimage.h"
 
+#define DEBUG_LEVEL 1
+
 /*::------------------------------------------------------------------::*/
 /*
  *	ATTENTION: cette fonction sert à faire des essais, et ne doit
@@ -16,8 +18,7 @@
  *
  *	n is the number of wanted colors 
  */
-int
+int Image_essai_col_reduce(Image_Desc *src, Image_Desc *dst, int n, int t)
-Image_essai_col_reduce(Image_Desc *src, Image_Desc *dst, int n, int t)
 {
 RGB_map		map;
 int		foo;

Lib/combine.c

@@ -4,7 +4,7 @@
 
 	made by Thierry Boudet, aka "Oulala", aka "Tonton Th".
 
-	ces fonctions combinent de diverses façons deux images
+	ces fonctions combinent de diverses facons deux images
 	de memes dimensions. on pourra, par exemple, les utiliser
 	pour comparer deux traitements.
 */
@@ -22,7 +22,7 @@
 
 /*::------------------------------------------------------------------::*/
 /*
- *	le paramètre 'zak' n'est pas utilisé et doit être mis à 0
+ *	le parametre 'zak' n'est pas utilise et doit etre mis a 0
  */
 int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 			int sy, int oy, int zak)
@@ -30,11 +30,11 @@ int Image_combine_lines(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 int	foo, x, y, my, r, g, b;
 
 if (sy == 0) {
-	fprintf(stderr, "Combine Lines: sy is zer0 and zak is %d\n", zak);
+	fprintf(stderr, "%s: sy is 0 and zak is %d\n", __func__, zak);
 	return DIVISOR_IS_ZERO;
 	}
 if ( (foo=Image_compare_desc(s1, s2)) ) {
-	fprintf(stderr, "Combine Lines: sources are differents (%d)\n", foo);
+	fprintf(stderr, "%s: sources are differents (%d)\n", __func__, foo);
 	return foo;
 	}
 
@@ -65,7 +65,7 @@ return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
 /*
- *	le paramètre 'zak' n'est pas utilisé et doit être mis à 0
+ *	le parametre 'zak' n'est pas utilise et doit etre mis a 0
  */
 int Image_combine_columns(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 			int sx, int ox, int zak)
@@ -241,8 +241,8 @@ return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
 /*
- *	le flag 'yo' decide quelle image sera en haut à droite.
+ *	le flag 'yo' decide quelle image sera en haut a droite.
- *	les paramètres p1 & p2 ne sont pas utilisés.
+ *	les parametres p1 & p2 ne sont pas utilises.
  */
 int Image_combine_diagonale(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 				int yo, int p1, int p2)
@@ -252,7 +252,7 @@ int	x, y, r, g, b;
 int	vertical, offset;
 
 if ( p1 || p2 ) {
-	fprintf(stderr, "in %s bad p1 %d or bad p2 %d\n", __func__, p1, p2);
+	fprintf(stderr, "%s: bad p1 %d or bad p2 %d\n", __func__, p1, p2);
 	}
 
 if ( (foo=Image_compare_desc(s1, s2)) ) {
@@ -300,6 +300,7 @@ for (y=0; y<s1->height; y++) {
 	}
 /*
  * 30 sept 2008 : est-ce que cette fonction a subi un bon fuzzing ?
+ *  9 aout 2024 : non, pas encore ;)
  */
 return OLL_KORRECT;
 }
@@ -352,7 +353,7 @@ return OLL_KORRECT;
 /*
  *   fonction faite pour le finisseur de DBvsEE
  *
- *	6 oct 2001: une version qui permettrait de spécifier les
+ *	6 oct 2001: une version qui permettrait de specifier les
  *		seuils en r,g et b serait assez pratique aussi.
  */
 int Image_combine_if_not_black(Image_Desc *s1, Image_Desc *s2, Image_Desc *d)

Lib/combine3.c

@@ -13,42 +13,35 @@
 /*
  *	un kludge en chantier. programmation à la 'Gruiik' en vue.
  */
-int
+int Image_combine_waou(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
-Image_combine_waou(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
 					int a, int b, int c, int d)
 {
 int	x, y, foo;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %p %p %d : %d %d (%d) )\n",
+fprintf(stderr, ">>> %s ( %p %p %p %d : %d %d (%d) )\n",
 			 __func__, s1, s2, dst, a, b, c, d);
 #endif
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-    {
     fprintf(stderr, "%s : sources are differents %d\n", __func__, foo);
     return foo;
     }
 
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-    {
     fprintf(stderr, "%s : destination bad dims %d\n", __func__, foo);
     return foo;
     }
 
-for (y=0; y<dst->height; y++)
+for (y=0; y<dst->height; y++) {
-	{
+	for (x=0; x<dst->width; x++) {
-	for (x=0; x<dst->width; x++)
+		if (d)	{
-		{
-		if (d)
-			{
 			/* canonical function */
 			(dst->Rpix[y])[x] = (x & (s1->Rpix[y])[x]) | a;
 			(dst->Gpix[y])[x] = x | b;
 			(dst->Bpix[y])[x] = (y & (s2->Rpix[y])[x]) | c;
 			}
-		else
+		else	{
-			{
 			/* new 9 mars 2010 - ave St Ex */
 			(dst->Rpix[y])[x] = (x & (s1->Rpix[y])[x]) ^ a;
 			(dst->Gpix[y])[x] = x ^ b;
@@ -62,9 +55,8 @@ return FUNC_IS_BETA;
 /*::------------------------------------------------------------------::*/
 /*
  *	un kludge en chantier. programmation à la 'Gruiik' en vue.
- */
+ */ 
-int
+int Image_combine_wauo(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
-Image_combine_wauo(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
 						int flag)
 {
 int	x, y, foo;
@@ -72,31 +64,25 @@ int	x, y, foo;
 if ( flag )
 	fprintf(stderr, "Combine Wauo: flag = %d ?\n", flag);
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-    {
     fprintf(stderr, "Combine Wauo: sources are differents %d\n", foo);
     return foo;
     }
 
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-    {
     fprintf(stderr, "Combine Wauo: destination bad dims %d\n", foo);
     return foo;
     }
 
-for (y=1; y<dst->height-1; y++)
+for (y=1; y<dst->height-1; y++) {
-	{
+	for (x=1; x<dst->width-1; x++) {
-	for (x=1; x<dst->width-1; x++)
-		{
 		(dst->Rpix[y])[x] = (s1->Rpix[y][x] + s2->Rpix[y][x])/2;
 
-		if (s1->Rpix[y][x] > s2->Rpix[y][x])
+		if (s1->Rpix[y][x] > s2->Rpix[y][x]) {	
-			{	
 			(dst->Gpix[y])[x] = (s1->Gpix[y])[x];
 			(dst->Bpix[y])[x] = (s2->Bpix[y])[x];
 			}
-		else
+		else	{	
-			{	
 			(dst->Gpix[y])[x] = (s2->Gpix[y])[x];
 			(dst->Bpix[y])[x] = (s1->Bpix[y])[x];
 			}
@@ -109,31 +95,26 @@ return OLL_KORRECT;
 /*
  *   threshold values (sr, sg, sb) are in the pix range [0..255]
  */
-int
+int Image_combine_seuils(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
-Image_combine_seuils(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst,
 						int sr, int sb, int sg)
 {
 int	x, y, foo;
 int	r, g, b;
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-    {
     fprintf(stderr, "Combine Seuils: sources are differents %d\n", foo);
     return foo;
     }
 
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-    {
     fprintf(stderr, "Combine Seuils: destination bad dims %d\n", foo);
     return foo;
     }
 
 sr*=2;	sg*=2;	sb*=2;
 
-for (y=0; y<dst->height; y++)
+for (y=0; y<dst->height; y++) {
-	{
+	for (x=0; x<dst->width; x++) {
-	for (x=0; x<dst->width; x++)
-		{
 		if ( (s1->Rpix[y][x] + s2->Rpix[y][x]) > sr )
 			r = s1->Rpix[y][x];
 		else

Lib/contrast.c

@@ -14,6 +14,7 @@
  */
 int Image_egalise_cos01(Image_Desc *source, Image_Desc *but, int k)
 {
+(void)k;				/* WARNING KILLER */
 int		lut[256], uc, idx, foo;
 float		fidx;
 
@@ -34,11 +35,16 @@ for (idx=0; idx<256; idx++) {
 	}
 Image_LUT_mono(source, but, lut);
 
-return FUNC_IS_BETA;
+return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
+/*
+ *	new: Fri Sep 15 20:32:12 UTC 2023
+ *	inspired by the same func in FloatImg
+ */
 int Image_egalise_cos010(Image_Desc *source, Image_Desc *but, int k)
 {
+(void)k;				/* WARNING KILLER */
 int		lut[256], uc, idx, foo;
 float		fidx;
 
@@ -59,7 +65,7 @@ for (idx=0; idx<256; idx++) {
 	}
 Image_LUT_mono(source, but, lut);
 
-return FUNC_IS_BETA;
+return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
 /*

Lib/equalhist.c

@@ -0,0 +1,15 @@
+/*
+ *	Egalisation par cumul d'histogramme
+ *	===================================
+ *
+ * new: Sat Aug 10 14:38:01 UTC 2024, aux Bourtoulots
+ */
+
+
+#include  <stdio.h>
+#include  <math.h>
+#include  "../tthimage.h"
+
+
+/*::------------------------------------------------------------------::*/
+

Lib/essais.c

@@ -145,7 +145,7 @@ Image_TGA_save("Pictures/aaaa-luminance-128.tga", dst, 0);
 foo = Image_luminance(src, dst, 200);
 Image_TGA_save("Pictures/aaaa-luminance-200.tga", dst, 0);
 foo = Image_luminance(src, dst, 500);
-if (foo) Image_print_error(__func__, foo);
+if (foo) Image_print_error((char *)__func__, foo);
 
 Image_TGA_save("Pictures/aaaa-luminance-500.tga", dst, 0);
 
@@ -216,18 +216,17 @@ if (NULL==(src=Image_TGA_alloc_load(srcname))) {
 	}
 /* on va creer le receptacle des horreurs */
 if (NULL==(dst=Image_clone(src, 0))) {
+	fprintf(stderr, "%s: err clone\n", __func__);
 	exit(5);
 	}
 
 /* ah bravo ! enfin un test unitaire appelable
  * depuis le test unitaire */
-for (idx=0; idx<20; idx++)
+for (idx=0; idx<20; idx++) {
-	{
 	foo = Image_essai_col_reduce(src, dst, 133, idx);
 	printf("le retour de l'essai_col_reduce %d est %d\n", idx, foo);
-	if (OLL_KORRECT==foo)
+	if (OLL_KORRECT==foo) {
-		{
+		sprintf(fname, "aaaa-colredux-%02d.tga", idx);
-		sprintf(fname, "Pictures/aaaa-colredux-%02d.tga", idx);
 		Image_TGA_save(fname, dst, 0);
 		}
 	}
@@ -471,7 +470,6 @@ int		rotule, foo;
 Image_Desc	*origine, *imgtmp;
 char		chaine[100];
 int		filtre[11];
-int		w3, h3;
 Image_Rect      rect;
 
 static	int	datas_sobel[] =
@@ -513,9 +511,6 @@ printf("image originale @ %p\n", origine);
 
 imgtmp = Image_clone(origine, 1);
 
-w3 = origine->width * 3;
-h3 = origine->height * 3;
-
 if (flags)	memcpy(filtre, datas_prewitt, sizeof(filtre));
 else		memcpy(filtre, datas_sobel, sizeof(filtre));
 
@@ -586,32 +581,30 @@ int		foo, ax, ay;
 
 printf("====== essais Warping sur %s (k=%d) ====\n", srcname, k);
 
-if (NULL == (src = Image_TGA_alloc_load(srcname)) )
+if (NULL == (src = Image_TGA_alloc_load(srcname)) ) {
-	{
 	fprintf(stderr, "Err loading '%s'\n", srcname);
 	exit(5);
 	}
 dst = Image_clone(src, 0);
 
 foo = Image_warp_essai_0(src, dst, 33.5, 100, 100);
-Image_TGA_save("Pictures/warp-essai-0.tga", dst, 0);
+Image_TGA_save("warp-essai-0.tga", dst, 0);
 
 foo = Image_center_rotate(src, dst, 21.5);
-Image_TGA_save("Pictures/warp-center-rotate.tga", dst, 0);
+Image_TGA_save("warp-center-rotate.tga", dst, 0);
 
 ax = (src->width * 2) / 3;
 ay = (src->height * 2) / 3;
 foo = Image_shift_xy(src, dst, ax, ay);
-Image_TGA_save("Pictures/warp-shift-xy.tga", dst, 0);
+Image_TGA_save("warp-shift-xy.tga", dst, 0);
 foo = Image_shift_x(src, dst, ax);
-Image_TGA_save("Pictures/warp-shift-x.tga", dst, 0);
+Image_TGA_save("warp-shift-x.tga", dst, 0);
 foo = Image_shift_y(src, dst, ay);
-Image_TGA_save("Pictures/warp-shift-y.tga", dst, 0);
+Image_TGA_save("warp-shift-y.tga", dst, 0);
 
 Image_DeAllocate(src);  free(src);
 Image_DeAllocate(dst);  free(dst);
 
-
 return 42;
 }
 /*::------------------------------------------------------------------::*/
@@ -799,7 +792,7 @@ Image_DeAllocate(dst);	free(dst);
 return 42;
 }
 /*::------------------------------------------------------------------::*/
-int Test_classif(char *srcname, int k)
+int Test_Classif(char *srcname, int k)
 {
 Image_Desc	*src, *dst;
 int		foo;
@@ -816,8 +809,7 @@ static Une_Classe_Sph classs[] =
 	{   0, 255,   0,   DC,     0, 255,   0 }
 	};
 
-if (NULL == (src = Image_TGA_alloc_load(srcname)) )
+if (NULL == (src = Image_TGA_alloc_load(srcname)) ) {
-	{
 	fprintf(stderr, "Err loading '%s'\n", srcname);
 	exit(5);
 	}
@@ -825,11 +817,11 @@ dst = Image_clone(src, 0);
 
 foo = Image_classif_0(src, dst);
 Image_print_error("essai classif 0", foo);
-Image_TGA_save("Pictures/aaaa-classif0.tga", dst, 0);
+Image_TGA_save("aaaa-classif0.tga", dst, 0);
 
 foo = Image_classif_1(src, dst, classs, 5, 0);
 Image_print_error("essai classif 1", foo);
-Image_TGA_save("Pictures/aaaa-classif1.tga", dst, 0);
+Image_TGA_save("aaaa-classif1.tga", dst, 0);
 
 Image_DeAllocate(src);	free(src);
 Image_DeAllocate(dst);	free(dst);
@@ -838,23 +830,29 @@ return 42;
 }
 /*::------------------------------------------------------------------::*/
 /* new 24 avril 2007, essais sur le module rgbmask.c			*/
-int
+int Test_RGBmask(char *srcname)
-Test_rgbmask(char *srcname)
 {
 Image_Desc *source, *image ;
 int		foo;
 
+fprintf(stderr, "=============== %s on %s ==============\n", __func__, srcname);
+
+
 source = Image_TGA_alloc_load(srcname);
 image = Image_clone(source, 0);
 
 foo = Image_rgbmask_H(source, image, 0);
-Image_TGA_save("Pictures/aaaa-rgbmaskH.tga", image, 0);
+Image_TGA_save("aaaa-rgbmaskH.tga", image, 0);
 foo = Image_rgbmask_V(source, image, 0);
-Image_TGA_save("Pictures/aaaa-rgbmaskV.tga", image, 0);
+Image_TGA_save("aaaa-rgbmaskV.tga", image, 0);
 foo = Image_rgbmask_2(source, image, 0);
-Image_TGA_save("Pictures/aaaa-rgbmask2.tga", image, 0);
+Image_TGA_save("aaaa-rgbmask2.tga", image, 0);
 foo = Image_rgbmask_R(source, image, 0);
-Image_TGA_save("Pictures/aaaa-rgbmaskR.tga", image, 0);
+Image_TGA_save("aaaa-rgbmaskR.tga", image, 0);
+
+Image_DeAllocate(source);	free(source);
+Image_DeAllocate(image);	free(image);
+
 
 return  42;
 }
@@ -1055,15 +1053,47 @@ Image_DeAllocate(finale);	free(finale);
 return 0;
 }
 /*::------------------------------------------------------------------::*/
-int
+/* new: Sat Aug 10 15:32:01 UTC 2024 */
-Test_Egalisations(char *nomsource, int k)
+int Essai_Televisions(char *nomsource, int k)
+{
+Image_Desc	*image, *resultat;
+int		foo;
+
+fprintf(stderr, "================ Televisions %s %d ========\n", nomsource, k);
+
+
+image = Image_TGA_alloc_load(nomsource);
+printf("%s : image loaded %p\n", __func__, image);
+resultat = Image_clone(image, 0);
+printf("%s : image cloned %p\n", __func__, resultat);
+
+foo = Image_TV_old(image, resultat, 127, 127, 127);
+printf("\tTV old -> %d\n", foo);
+Image_TGA_save("aaaa_tv_old.tga", resultat, 0);
+
+foo = Image_TV_pix_0(image, resultat, 7, 7, 0);
+printf("\tTV pix 0 -> %d\n", foo);
+Image_TGA_save("aaaa_tv_pix_0.tga", resultat, 0);
+
+foo = Image_TV_cplus_v1(image, resultat, 7);
+printf("\tTV cplus v1 -> %d\n", foo);
+Image_TGA_save("aaaa_tv_cplusV1.tga", resultat, 0);
+
+
+Image_DeAllocate(image);	free(image);
+Image_DeAllocate(resultat);	free(resultat);
+
+return FULL_NUCKED;
+}
+/*::------------------------------------------------------------------::*/
+int Test_Egalisations(char *nomsource, int k)
 {
 Image_Desc *image, *deuxieme, *troisieme;
 int     x, y;
 
-fprintf(stderr, "============= Egalisations %s %d =====\n", nomsource, k);
+fprintf(stderr, "================ Egalisations %s %d =====\n", nomsource, k);
 
-image= Image_TGA_alloc_load(nomsource);
+image = Image_TGA_alloc_load(nomsource);
 printf("image loaded %p\n", image);
 
 deuxieme = Image_clone(image, 0);
@@ -1074,18 +1104,17 @@ troisieme = Image_clone(image, 0);
 printf("image 3 cloned %p\n", troisieme);
 Image_egalise_RGB(image, troisieme, 0);
 
-for (x=0; x<image->width; x++)
+for (x=0; x<image->width; x++) {
-	{
+	if (x < image->width/3) {
-	if (x < image->width/3)
+		for (y=0; y<image->height; y++) {
-		{
-		for (y=0; y<image->height; y++)
 			Image_pixel_copy(image, x, y, troisieme, x, y);
+			}
 		}
 	else
-	if (x > image->width/3*2)
+	if (x > image->width/3*2) {
-		{
+		for (y=0; y<image->height; y++) {
-		for (y=0; y<image->height; y++)
 			Image_pixel_copy(deuxieme, x, y, troisieme, x, y);
+			}
 		}
 
 #if DEBUG_LEVEL > 2
@@ -1095,7 +1124,7 @@ for (x=0; x<image->width; x++)
 
 printf("saving resultat...\n");
 Image_marque_1(troisieme, "Egalisations", 0);
-Image_TGA_save("Pictures/aaaa_egal.tga", troisieme, 0);
+Image_TGA_save("aaaa_egal.tga", troisieme, 0);
 Image_DeAllocate(image);	free(image);
 Image_DeAllocate(deuxieme);	free(deuxieme);
 Image_DeAllocate(troisieme);	free(troisieme);
@@ -1103,30 +1132,30 @@ Image_DeAllocate(troisieme);	free(troisieme);
 return 42;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Test_Dithering(char *nomsource, int k)
-Test_Dithering(char *nomsource, int k)
 {
 Image_Desc	*source, *image, *deuxieme, *finale;
 Image_Rect	rect;
-int		foo;
+int		foo, wf, hf;
 int		x2, y2;
 RGBA		ink, pap;
 
-fprintf(stderr, "========== Dithering on %s (%d) =======\n", nomsource, k);
+fprintf(stderr, "============== Dithering on %s (%d) =======\n", nomsource, k);
 
 source = Image_TGA_alloc_load(nomsource);
-if (NULL == source)
+if (NULL == source) {
-	{
 	fprintf(stderr, "%s:%s err load %s\n", __FILE__, __func__, nomsource);
 	exit(5);
 	}
+#if DEBUG_LEVEL
 Image_dump_descriptor(source, "just after load");
+#endif
 
 /*
  * est-ce bien necessaire ?
  */
 /* Image_egalise_RGB(source, source, 0); */
-
+wf = source->width;		hf = (source->height) * 3;
 x2 = source->width / 2;		y2 = source->height / 2;
 rect.w = x2;			rect.h = y2;
 rect.x = 0;			rect.y = 0;
@@ -1134,24 +1163,22 @@ rect.x = 0;			rect.y = 0;
 ink.r = 255, ink.g = 255, ink.b = 100;		ink.a = 255;
 pap.r =  30, pap.g =  30, pap.b = 155;		pap.a = 255;
 
-finale = Image_alloc(source->width, (source->height)*3, 3);
+finale = Image_alloc(wf, hf, 3);
-if (NULL == finale)
+if (NULL == finale) {
-	{
 	fprintf(stderr, "%s:%s:%d err alloc image\n",
 			__FILE__, __func__, __LINE__);
 	exit(5);
 	}
-printf("image finale allocated %p\n", finale);
+Image_clear(finale, 0, 200, 0);
+printf("image finale %dx%d allocated at %p\n", wf, hf, finale);
 
 image = Image_MakeHalfSize(source, 0);
-if (NULL == image)
+if (NULL == image) {
-	{
 	fprintf(stderr, "%s:%s:%d err halfsize image\n",
 			__FILE__, __func__, __LINE__);
 	exit(5);
 	}
-
+printf("%s: image Half at %p\n", __func__, image);
-printf("image Half -> %p\n", image);
 
 Image_DeAllocate(source);	free(source);
 Image_copy_rect(image, &rect, finale, 0, 0);
@@ -1197,17 +1224,20 @@ Image_txt1_box_0(finale, "3x3 2", x2, y2*3, 4, &pap, &ink, 0);
 foo = Image_dither_bayer8x8rnd(image, deuxieme, 5000, 0);
 printf("retour Dither bayer8x8rnd = %d\n", foo);
 Image_copy_rect(deuxieme, &rect, finale, x2, y2*4);
-Image_txt1_box_0(finale, "bayer 8x8 rnd rgb", x2, y2*4, 4, &pap, &ink, 0);
+Image_txt1_box_0(finale, "bayer8xrnd rgb", x2, y2*4, 4, &pap, &ink, 0);
 
 foo = Image_dither_bayer8x8rnd(image, deuxieme, 5000, 1);
 printf("retour Dither bayer8x8rnd = %d\n", foo);
 Image_copy_rect(deuxieme, &rect, finale, 0, y2*4);
-Image_txt1_box_0(finale, "bayer 8x8 rnd grey", 0, y2*4, 4, &pap, &ink, 0);
+Image_txt1_box_0(finale, "bayer8x8rndgrey", 0, y2*4, 4, &pap, &ink, 0);
 
-Image_TGA_save("Pictures/aaaa_dithering.tga", finale, 0);
+printf("++++++ test dither\n");
+Image_dump_descriptor(finale, "just before save");
+Image_TGA_save("aaaa_dithering.tga", finale, 0);
 Image_DeAllocate(image);	free(image);
 Image_DeAllocate(deuxieme);	free(deuxieme);
 Image_DeAllocate(finale);	free(finale);
+printf("++++++ fin essais dither\n");
 
 return 0;
 }
@@ -1226,8 +1256,7 @@ return -1;
 }
 /*::------------------------------------------------------------------::*/
 /* new 21 juillet 2007 - ave St Exupery */
-int
+int Test_Effects_A(char *nomsource, int flag)
-Test_Effects_A(char *nomsource, int flag)
 {
 Image_Desc *source, *image, *deuxieme, *finale;
 int	foo;
@@ -1236,8 +1265,7 @@ RGBA		ink, pap;
 
 printf("=== %s %s === %s === %d ===\n", __FILE__, __func__, nomsource, flag);
 
-if (flag)
+if (flag) {
-	{
 	fprintf(stderr, "%s: flag is %d ?\n", __func__, flag);
 	}
 
@@ -1245,8 +1273,7 @@ ink.r = 255, ink.g = 255, ink.b = 100;		ink.a = 255;
 pap.r =  30, pap.g =  30, pap.b = 155;		pap.a = 255;
 
 source = Image_TGA_alloc_load(nomsource);
-if (NULL==source)
+if (NULL==source) {
-	{
 	fprintf(stderr, "%s : il manque '%s'\n", __func__, nomsource);
 	exit(1);
 	}
@@ -1322,8 +1349,7 @@ Image_DeAllocate(finale);	free(finale);
 return 42;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Test_des_tamppools(char *imgname, int param)
-Test_des_tamppools(char *imgname, int param)
 {
 void	*ptr;
 int	foo;
@@ -1346,30 +1372,31 @@ int Test_des_filtres(char *srcname, int k)
 Image_Desc	*src, *dst;
 int		foo;
 
-printf("======= LES FILTRES ===[ %s ]==[ %d ]====\n", srcname, k);
+printf("=============== Filtres =====[ %s ]====[ %d ]====\n", srcname, k);
 
 src = Image_TGA_alloc_load(srcname);
-if (NULL == src)
+if (NULL == src) {
-	{
 	fprintf(stderr, "%s can't load %s\n", __func__, srcname);
 	return 666;
 	}
 dst = Image_clone(src, 1);
-if (NULL == dst)
+if (NULL == dst) {
-	{
 	fprintf(stderr, "mem failure in %s\n", __func__);
 	abort();
 	}
 
 foo = Image_lissage_3x3(src, dst);
-Image_TGA_save("Pictures/filtre-liss3x3.tga", dst, 0);
+Image_TGA_save("filtre-liss3x3.tga", dst, 0);
 if (foo) { fprintf(stderr, "%s: liss3x3   -> %d\n", __func__, foo); }
 foo = Image_filtre_Prewitt(src, dst, 5);
-Image_TGA_save("Pictures/filtre-prewitt-5.tga", dst, 0);
+Image_TGA_save("filtre-prewitt-5.tga", dst, 0);
 foo = Image_filtre_passe_haut(src, dst);
-Image_TGA_save("Pictures/filtre-passe-haut.tga", dst, 0);
+Image_TGA_save("filtre-passe-haut.tga", dst, 0);
+
+/*
 foo = Image_filtre_Sobel_4(src, dst, 0);
-Image_TGA_save("Pictures/filtre-sobel-4.tga", dst, 0);
+Image_TGA_save("filtre-sobel-4.tga", dst, 0);
+*/
 
 Image_DeAllocate(src);	free(src);
 Image_DeAllocate(dst);	free(dst);
@@ -1465,3 +1492,17 @@ Image_DeAllocate(dst);	free(dst);
 return -1;
 }
 /*::------------------------------------------------------------------::*/
+/*		==============================				*/
+
+void essai_gradients(void)
+{
+int		foo;
+
+foo = Image_plot_H_gradient("foo.tga", 640, 200);
+fprintf(stderr, "plot h gradient -> %d\n", foo);
+foo = Image_plot_V_gradient("foo.tga", 900, 200);
+fprintf(stderr, "plot v gradient -> %d\n", foo);
+}
+/*		==============================				*/
+/*::------------------------------------------------------------------::*/
+

Lib/essais.h

@@ -27,6 +27,8 @@ int Essai_des_lut15bits(char *srcname, int k);
 int Essai_des_mires(char *, int, int);
 int Essai_des_zooms(char *srcname, int k);
 
+int Test_Classif(char *srcname, int k);
+
 int Essai_des_7_segments(char *srcname, int flag);
 int Essai_des_distances(char *srcname, int nbre, int flag);
 int Essai_des_cadres(char *srcname, int flags);
@@ -44,7 +46,7 @@ int Test_des_df3(char *txt, int k);
 int Test_vignettes(char *srcname, int k);
 
 int Test_classif(char *srcname, int k);
-int Test_rgbmask(char *srcname);
+int Test_RGBmask(char *srcname);
 void Test_rgb2xyz(void);
 
 int  Essai_des_marquages(char *srcname, int nombre, char *texte);
@@ -68,7 +70,7 @@ int Test_des_pixeliz(char *srcname, int flags);
 int Essai_des_bitblt(char *srcname, int k);
 int Essai_des_gadgrect(char *srcname, int k);
 
-int Essai_Television(char *source, int k);
+int Essai_Televisions(char *source, int k);
 
 /* dans essais2;c */
 int Essai_des_big_chars(char *fname, int k);

Lib/foo.c

@@ -8,53 +8,91 @@
 
 /*		==============================				*/
 
-int essai_false_colors(void)
+/* new Wed Aug 14 19:17:20 UTC 2024
+ *
+ *	parameters :
+ *		ip: Image_Desc * of input picture
+ *		ix, iy:	coordinate of the pixel in this pic.
+ *		op, ox, oy : same things for output picture
+ */
+#define PIXEL_COPY(ip, ix, iy, op, ox, oy)			\
+			do {					\
+			(op->Rpix[oy])[ox] = (ip->Rpix[iy])[ix];	\
+			(op->Gpix[oy])[ox] = (ip->Gpix[iy])[ix];	\
+			(op->Bpix[oy])[ox] = (ip->Bpix[iy])[ix];	\
+			} while (0)
+
+#define SZPIC   4096
+
+void essai_pixcopy(int usemacro)
 {
-int			foo;
+Image_Desc	*alice, *bob;
-RGB_map			luts;
+int		x, y, foo;
+double		T0, T1, perpix;
+long		count;
+char		*fname;
 
-foo = Image_gen_fc_lut(27e3, 33, &luts);
+alice = Image_alloc(SZPIC, SZPIC, IMAGE_RGB);
-fprintf(stderr, "retour gen_fc_lut = %d\n", foo);
+bob   = Image_alloc(SZPIC, SZPIC, IMAGE_RGB);
 
-return -1;
+Image_pattern_000(alice, 0);
+Image_TGA_save("alice.tga", alice, 0);
+
+T0 = tthi_dtime();
+count = 0L;
+
+if (usemacro) {
+	for (y=0; y<SZPIC; y++) {
+		for (x=0; x<SZPIC; x++) {
+			PIXEL_COPY(alice, x, y, bob, x, y);
+			count++;
+			}
+		}
+	fname = "bob1.tga";
+	}
+else {
+	for (y=0; y<SZPIC; y++) {
+		for (x=0; x<SZPIC; x++) {
+			Image_pixel_copy(alice, x, y, bob, x, y);
+			count++;
+			}
+		}
+	fname = "bob0.tga";
+	}
+
+T1 = tthi_dtime();
+
+foo = Image_TGA_save(fname, bob, 0);
+if (foo) {
+	fprintf(stderr, "%s: save -> %d\n", __func__, foo);
+	}
+
+perpix = ((T1-T0) / (double)count) * 1e6;
+fprintf(stderr, "%s : %10ld pixels, elapsed %9.6f seconds ==> %9.6f µs/pix\n",
+			usemacro ? "macro" : "func ",
+			count, T1-T0, perpix);
+
+/* end */
 }
 
 /*		==============================				*/
 
-int essai_show_t16x24( char *text)
-{
-if (NULL != text)
-	Image_t16x24_essai("16x24thin", text, "16x24.tga");
-else
-	Image_t16x24_essai("16x24gruik", "0123456789abcdef", "16x24.tga");
-return 0;
-}
-
-/*		==============================				*/
-
-void essai_gradients(void)
-{
-int		foo;
-
-foo = Image_plot_H_gradient("foo.tga", 640, 200);
-fprintf(stderr, "plot h gradient -> %d\n", foo);
-foo = Image_plot_V_gradient("foo.tga", 900, 200);
-fprintf(stderr, "plot v gradient -> %d\n", foo);
-}
-/*		==============================				*/
-
 int main(int argc, char *argv[])
 {
+int	i;
 
-fprintf(stderr, "*** %s is running\n", argv[0]);
+fprintf(stderr, "*********** %s ************\n", argv[0]);
 
 if (argc > 1) {
 	fprintf(stderr, "argument: %s\n", argv[1]);
-	Image_print_version(0);
+	Image_print_version(2);
 	Image_print_sizeof_structs("foo");
 	}
 else	{
-	essai_false_colors();
+	for (i=0; i<5; i++) {
+		essai_pixcopy(0);
+		essai_pixcopy(1);
+		}
 	}
 
 /*

Lib/functions.c

@@ -0,0 +1,27 @@
+/*
+ *		miscellaneous functions
+ *		-----------------------
+ *
+ * new:  Thu Aug 15 09:55:36 UTC 2024
+ *
+ */
+
+#include  <stdio.h>
+#include  <sys/time.h>
+
+#include  "../tthimage.h"
+
+/* ------------------------------------------------------------------- */
+/*
+ *	for what FSCKING reason, this func is not in the stdlib ???
+ */
+double tthi_dtime(void)
+{
+struct timeval  t;
+double          d;
+(void)gettimeofday(&t, NULL);
+d = (double)t.tv_sec + (double)t.tv_usec / 1e6;
+return d;
+}
+/* ------------------------------------------------------------------- */
+/* ------------------------------------------------------------------- */

Lib/image.c

@@ -93,8 +93,7 @@ return 0;
  *          on the structure who describe the image.
  *          - - - > don't "free" this pointer, please.
  */
-Image_Desc *
+Image_Desc * Image_alloc(int width, int height, int type)
-Image_alloc(int width, int height, int type)
 {
 Image_Desc   *header;
 int             foo;
@@ -192,19 +191,18 @@ return header;
 /*
       This fonction build another image from a model.
  */
-Image_Desc *
+Image_Desc * Image_clone (Image_Desc *src, int copy)
-Image_clone (Image_Desc *src, int copy)
 {
 Image_Desc *image;
 
-if ( src==NULL )
+if ( NULL == src )
     {
     fprintf(stderr, "Image_clone: source descriptor is NULL\n");
     exit(5);
     }
 
 image = Image_alloc(src->width, src->height, src->type);
-if ( image==NULL )
+if ( NULL == image )
     {
     fprintf(stderr, "Image_clone: cloned descriptor is NULL\n");
     exit(5);
@@ -246,20 +244,16 @@ return FUNC_IS_ALPHA;
  *	Helas, cette fonction ne marche que sur les images RGB
  *	et comment la rendre compatible tout-types sans tout casser ?
  */
-int
+int Image_clear( Image_Desc *image, int r, int g, int b )
-Image_clear( Image_Desc *image, int r, int g, int b )
 {
 int     x, y;
 
-if (image->type == IMAGE_RGB)
+if (image->type == IMAGE_RGB) {
-    {
+    for (y=0; y<image->height; y++) {
-    for (y=0; y<image->height; y++)
-        {
 		/*
 		 * XXX here we can go faster with a few memset
 		 */
-        for (x=0; x<image->width; x++)
+        for (x=0; x<image->width; x++) {
-            {
 	    (image->Rpix[y])[x] = r;
 	    (image->Gpix[y])[x] = g;
 	    (image->Bpix[y])[x] = b;
@@ -269,12 +263,9 @@ if (image->type == IMAGE_RGB)
     return 0;		/* ok, this 'return' here is a "spleyterie" :) */
     }
 
-if (image->type == IMAGE_RGBA)
+if (image->type == IMAGE_RGBA) {
-    {
+    for (y=0; y<image->height; y++) {
-    for (y=0; y<image->height; y++)
+        for (x=0; x<image->width; x++) {
-        {
-        for (x=0; x<image->width; x++)
-            {
 	    (image->Rpix[y])[x] = r;
 	    (image->Gpix[y])[x] = g;
 	    (image->Bpix[y])[x] = b;
@@ -309,6 +300,7 @@ if (IMAGE_RGB != img->type) {
 
 for (y=0; y<img->height; y++) {
 	for (x=0; x<img->width; x++) {
+		/* please, use memset here */
 		(img->Rpix[y])[x] = rgba->r;
 		(img->Gpix[y])[x] = rgba->g;
 		(img->Bpix[y])[x] = rgba->b;
@@ -321,8 +313,7 @@ return FUNC_IS_BETA;
  *	every image in memory have a comment field, who is writen
  *	in TGA and PNM file when image is saved.
  */
-int
+int Image_set_comment(Image_Desc *image, char *text)
-Image_set_comment(Image_Desc *image, char *text)
 {
 if (strlen(text) > IMG_OBJCOMMENT_LEN)
         return STRING_TOO_LONG;
@@ -331,8 +322,7 @@ return OLL_KORRECT;
 }
 /* 10 nov 2001: no #define for this not-so-magic 254 value ? */
 /*::------------------------------------------------------------------::*/
-int
+int Image_plot_gray(Image_Desc *img, int x, int y, int v)
-Image_plot_gray(Image_Desc *img, int x, int y, int v)
 {
 if ( x<0 || y<0 || x>=img->width || y>=img->height )
     {
@@ -352,8 +342,7 @@ int Image_plotRGB(Image_Desc *img, int x, int y, int r, int g, int b)
 fprintf(stderr, "PLOTRGB %d %d\n", x, y);
 #endif
 
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "Errplot RGB X=%d,  Y=%d     %d, %d, %d\n", x, y, r, g, b);
 #if FORCE_ABORT
 	abort();
@@ -368,8 +357,7 @@ return OLL_KORRECT;
 
 int Image_plotRGBA(Image_Desc *img, int x, int y, int r, int g, int b, int a)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
 /* may be an #if DEBUG_LEVEL here ? */
     fprintf(stderr, "Errplot RGBA   X %4d   Y %4d     %d, %d, %d, %d\n",
 				 x, y,		  r, g, b, a);
@@ -387,11 +375,9 @@ if ( x<0 || y<0 || x>=img->width || y>=img->height )
 return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_getRGB(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb)
-Image_getRGB(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
 /* may be an #if DEBUG_LEVEL here ? */
     fprintf(stderr, "ERR GETRGB  X %4d   Y %4d\n", x, y);
 #if FORCE_ABORT
@@ -407,11 +393,9 @@ if ( x<0 || y<0 || x>=img->width || y>=img->height )
 return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_getRGBA(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb, int *pa)
-Image_getRGBA(Image_Desc *img, int x, int y, int *pr, int *pg, int *pb, int *pa)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "ERR GETRGBA  X %4d   Y %4d\n", x, y);
 #if FORCE_ABORT
 	abort();
@@ -419,10 +403,9 @@ if ( x<0 || y<0 || x>=img->width || y>=img->height )
     return OUT_OF_IMAGE;
     }
 
-if (img->type != IMAGE_RGBA)
+if (img->type != IMAGE_RGBA) {
-    {
+    fprintf(stderr, "%s: bad image type: %d, %s\n",
-    fprintf(stderr, "Image get RGBA: bad image type: %d, %s\n",
+					__func__, img->type, Image_type2str(img->type));
-					img->type, Image_type2str(img->type));
 #if FORCE_ABORT
 	abort();
 #endif
@@ -443,16 +426,14 @@ return OLL_KORRECT;
  */
 int Image_plot_channel(Image_Desc *img, char channel, int x, int y, int value)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
 #if DEBUG_LEVEL
     fprintf(stderr, "ERR PLOTCHANNEL  X %4d   Y %4d\n", x, y); 
 #endif
     return OUT_OF_IMAGE;
     }
 
-switch (channel)
+switch (channel) {
-	{
 	case 'r': case 'R': (img->Rpix[y])[x] = (uint8_t)(value&0xff); break;
 	case 'g': case 'G': (img->Gpix[y])[x] = (uint8_t)(value&0xff); break;
 	case 'b': case 'B': (img->Bpix[y])[x] = (uint8_t)(value&0xff); break;
@@ -466,44 +447,36 @@ return OLL_KORRECT;
 /*
       lecture d'une des composantes de l'image.
  */
-int
+int Image_R_pixel(Image_Desc *img, int x, int y)
-Image_R_pixel(Image_Desc *img, int x, int y)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "ERR READ R PIX  X%d Y%d\n", x, y);
     return OUT_OF_IMAGE;
     }
 return (int)((img->Rpix[y])[x]);
 }
 
-int
+int Image_G_pixel(Image_Desc *img, int x, int y)
-Image_G_pixel(Image_Desc *img, int x, int y)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "ERR READ G PIX  X%d Y%d\n", x, y);
     return OUT_OF_IMAGE;
     }
 return (int)((img->Gpix[y])[x]);
 }
 
-int
+int Image_B_pixel(Image_Desc *img, int x, int y)
-Image_B_pixel(Image_Desc *img, int x, int y)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "ERR READ B PIX  X%d Y%d\n", x, y);
     return OUT_OF_IMAGE;
     }
 return (int)((img->Bpix[y])[x]);
 }
 
-int
+int Image_A_pixel(Image_Desc *img, int x, int y)
-Image_A_pixel(Image_Desc *img, int x, int y)
 {
-if ( x<0 || y<0 || x>=img->width || y>=img->height )
+if ( x<0 || y<0 || x>=img->width || y>=img->height ) {
-    {
     fprintf(stderr, "ERR A PIX  X%d Y%d\n", x, y);
     return OUT_OF_IMAGE;
     }
@@ -545,7 +518,7 @@ return 0;
 }
 /*::------------------------------------------------------------------::*/
 /*
- *	no boundary control ?
+ *	no boundary control ? XXX
  */
 int Image_pixel_copy(Image_Desc *s, int x, int y, Image_Desc *d, int i, int j)
 {
@@ -563,18 +536,16 @@ return OLL_KORRECT;
  */
 int Image_compare_desc(Image_Desc *a, Image_Desc *b)
 {
-char	*fmt = "Image at %p have no 'Dead Beef' in it\n";
+char	*fmt = "%s: Image at %p have no 'Dead Beef' in it\n";
 
 if ( (a==NULL) || (b==NULL) )   return NULL_DESCRIPTOR;
 
-if ( a->magic != MAGIC_OF_IMAGE )
+if ( a->magic != MAGIC_OF_IMAGE ) {
-	{
+	fprintf(stderr, fmt, __func__, a);
-	fprintf(stderr, fmt, a);
 	return NOT_AN_IMAGE_DESC;
 	}
-if ( b->magic != MAGIC_OF_IMAGE )
+if ( b->magic != MAGIC_OF_IMAGE ) {
-	{
+	fprintf(stderr, fmt, __func__, a);
-	fprintf(stderr, fmt, a);
 	return NOT_AN_IMAGE_DESC;
 	}
 
@@ -592,8 +563,7 @@ return OLL_KORRECT;
 		c'est qu'il reste un pointeur fou chez
 		l'appelant ...
 */
-int
+int Image_DeAllocate(Image_Desc *im)
-Image_DeAllocate(Image_Desc *im)
 {
 int     line;
 

Lib/operat.c

@@ -167,9 +167,9 @@ if ( (foo=Image_compare_desc(src, dst)) ) {
 if((histr=(long *)alloca(256*sizeof(long))) == NULL) return BUFFER_NO_MEM;
 if((histg=(long *)alloca(256*sizeof(long))) == NULL) return BUFFER_NO_MEM;
 if((histb=(long *)alloca(256*sizeof(long))) == NULL) return BUFFER_NO_MEM;
-if((cumlr=(int *)alloca(256*sizeof(int))) == NULL) return BUFFER_NO_MEM;
+if((cumlr=(int  *)alloca(256*sizeof(int)))  == NULL) return BUFFER_NO_MEM;
-if((cumlg=(int *)alloca(256*sizeof(int))) == NULL) return BUFFER_NO_MEM;
+if((cumlg=(int  *)alloca(256*sizeof(int)))  == NULL) return BUFFER_NO_MEM;
-if((cumlb=(int *)alloca(256*sizeof(int))) == NULL) return BUFFER_NO_MEM;
+if((cumlb=(int  *)alloca(256*sizeof(int)))  == NULL) return BUFFER_NO_MEM;
 
 Image_histo_RGB(src, histr, histg, histb);
 

Lib/pov_hf15e.c

@@ -2,7 +2,7 @@
                 pov_hf15e.c
                 ===========
 
-	opérations de morphologie mathématique appliquées
+	operations de morphologie mathematique appliquees
 	aux height-fields.
 
 */
@@ -18,40 +18,30 @@ static struct
 	int	x, y;
 	} off[] = 
 	{
-	{ -1, -1 },
+	{ -1, -1 },	{  0, -1 },	{  1, -1 },
-	{  0, -1 },
+	{ -1,  0 },	{  0,  0 },	{  1,  0 },
-	{  1, -1 },
+	{ -1,  1 },	{  0,  1 },	{  1,  1 }
-	{ -1,  0 },
-	{  0,  0 },
-	{  1,  0 },
-	{ -1,  1 },
-	{  0,  1 },
-	{  1,  1 }
 	};
 /*::------------------------------------------------------------------::*/
 /*
- *	le paramètre 'coef' n'est pas utilisé. D'ailleurs, je ne vois
+ *	le parametre 'coef' n'est pas utilise. D'ailleurs, je ne vois
  *	pas trop quoi y mettre ?
  */
-int
+int Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef)
-Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef)
 {
+(void)coef;		/* KILL WARNING */
 int	foo;
 int	x, y, h, hmax;
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "Image hf15 dilate: images differents %d\n", foo);
     return foo;
     }
 
-for (y=1; y<dst->height-1; y++)
+for (y=1; y<dst->height-1; y++) {
-	{
+	for (x=1; x<dst->width-1; x++) {
-	for (x=1; x<dst->width-1; x++)
-		{
 		hmax = -1664;
-		for (foo=0; foo<9; foo++)
+		for (foo=0; foo<9; foo++) {
-			{
 			h = Image_hf15_height(src, x+off[foo].x, y+off[foo].y);
 			if (h > hmax) hmax = h;
 			}
@@ -63,27 +53,23 @@ return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 /*
- *	le paramètre 'coef' n'est pas utilisé.
+ *	le parametre 'coef' n'est pas utilise.
  */
-int
+int Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef)
-Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef)
 {
+(void)coef;		/* KILL WARNING */
 int	foo;
 int	x, y, h, hmin;
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "Image hf15 erode: images differents %d\n", foo);
     return foo;
     }
 
-for (y=1; y<dst->height-1; y++)
+for (y=1; y<dst->height-1; y++) {
-	{
+	for (x=1; x<dst->width-1; x++) {
-	for (x=1; x<dst->width-1; x++)
-		{
 		hmin = 42042;
-		for (foo=0; foo<9; foo++)
+		for (foo=0; foo<9; foo++) {
-			{
 			h = Image_hf15_height(src, x+off[foo].x, y+off[foo].y);
 			if (h < hmin) hmin = h;
 			}
@@ -95,7 +81,7 @@ return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 /*
- *		Et maintenant, il reste à coder le chapeau haut-de-forme
+ *		Et maintenant, il reste a coder le chapeau haut-de-forme
  */
 /*::------------------------------------------------------------------::*/
 

Lib/recurse.c

@@ -4,6 +4,7 @@
 */
 
 #include   <stdio.h>
+#include   <stdlib.h>
 #include   <math.h>
 
 #include   "../tthimage.h"
@@ -15,6 +16,8 @@
  *	fait le meme genre de truc, mais en bien mieux...
  *
  */
+
+/*	Private variables */
 static	Image_Desc	*S, *D;
 static	int		seuil;
 static  int		level, maxlevel;
@@ -25,7 +28,8 @@ Image_Rect 	rect;
 int		h1, h2, w1, w2, xx, yy, foo;
 int		mr, mg, mb, dr, dg, db, s;
 
-level++;
+level++;		/* pourquoi ? */
+
 if (level > maxlevel)
 	maxlevel = level;
 
@@ -35,10 +39,16 @@ fprintf(stderr, "%5d  ->  %3d %3d    %3d %3d\n",
 #endif 
 
 foo = Image_stats_zone_0(S, pRect, &mr, &mg, &mb, &dr, &dg, &db);
+if (foo) {
+	fprintf(stderr, "%s: err stat zone %d\n", __func__, foo);
+	exit(1);
+	}
+
 s = (dr + dg + db) / 3;
-#if DEBUG_LEVEL > 1
+
-printf(" %7d  V %3d %3d %3d   D %3d %3d %3d   S %3d  (%d)\n",
+#if 1
-			 pRect->w*pRect->h, mr, mg, mb, dr, dg, db, s, foo);
+printf(" %7d   V %3d %3d %3d    D %3d %3d %3d    S  %3d\n",
+			 pRect->w*pRect->h, mr, mg, mb, dr, dg, db, s);
 #endif
 
 if ( (s < seuil) || (pRect->w < 6) || (pRect->h < 6) ) {
@@ -116,6 +126,10 @@ int Image_call_recursion_0(Image_Desc *image, Image_Desc *dest, int param)
 Image_Rect 	rect;
 int		foo;
 
+#if 1
+fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, image, dest, param);
+#endif
+
 rect.x = rect.y = 0;
 rect.h = image->height;
 rect.w = image->width;
@@ -135,17 +149,7 @@ fprintf(stderr, "->  fin recursion: %d, maxlevel=%d\n", foo, maxlevel);
 
 dest->modified = 1;
 
-return FUNC_IS_ALPHA;
+return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
-int
-Image_call_recursion(Image_Desc *image, Image_Desc *dest, int param)
-{
-int	foo;
-
-fprintf(stderr, "XXX %s is obsolete XXX\n", __func__);
-foo = Image_call_recursion_0(image, dest, param);
-
-return foo;
-}
 /*::------------------------------------------------------------------::*/

Lib/rgbmask.c

@@ -16,25 +16,20 @@
 /*
  *	horizontal lines
  */
-int
+int Image_rgbmask_H(Image_Desc *src, Image_Desc *dst, int gris)
-Image_rgbmask_H(Image_Desc *src, Image_Desc *dst, int gris)
 {
 int  foo, x, y;
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "%s : images are differents %d\n", __func__, foo);
     return foo;
     }
 
 Image_copy(src, dst);		/* XXX pourquoi cette copie ? */
 
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
+		switch (y%3) {
-		{
-		switch (y%3)
-			{
 			case 0:
 				Image_plot_channel(dst, 'r', x, y, gris);
 				Image_plot_channel(dst, 'g', x, y, gris);
@@ -57,25 +52,19 @@ return FUNC_IS_BETA;
 /*
  *	vertical lines
  */
-int
+int Image_rgbmask_V(Image_Desc *src, Image_Desc *dst, int gris)
-Image_rgbmask_V(Image_Desc *src, Image_Desc *dst, int gris)
 {
 int  foo, x, y;
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "Image rgbmask V: images are differents %d\n", foo);
     return foo;
     }
-
 Image_copy(src, dst);
 
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
+		switch (x%3) {
-		{
-		switch (x%3)
-			{
 			case 0:
 				Image_plot_channel(dst, 'r', x, y, gris);
 				Image_plot_channel(dst, 'g', x, y, gris);
@@ -98,26 +87,21 @@ return FUNC_IS_BETA;
 /*
  *	sequential dots - _very_ dependant on image dimensions.
  */
-int
+int Image_rgbmask_2(Image_Desc *src, Image_Desc *dst, int gris)
-Image_rgbmask_2(Image_Desc *src, Image_Desc *dst, int gris)
 {
 int  foo, x, y;
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "Image rgbmask 2: images are differents %d\n", foo);
     return foo;
     }
 Image_copy(src, dst);
 
 foo = 0;
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
-		{
 		foo++;
-		switch (foo%3)
+		switch (foo%3) {
-			{
 			case 0:
 				Image_plot_channel(dst, 'r', x, y, gris);
 				Image_plot_channel(dst, 'g', x, y, gris);
@@ -140,8 +124,7 @@ return FUNC_IS_BETA;
 /*
  *	random dots - VERY BAD RESULTS :(
  */
-int
+int Image_rgbmask_R(Image_Desc *src, Image_Desc *dst, int gris)
-Image_rgbmask_R(Image_Desc *src, Image_Desc *dst, int gris)
 {
 int  foo, x, y;
 
@@ -149,20 +132,16 @@ int  foo, x, y;
 fprintf(stderr, "this function, %s(%d), is very buggy...\n", __func__, gris);
 #endif
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-    {
     fprintf(stderr, "Image rgbmask R: images are differents %d\n", foo);
     return foo;
     }
 Image_copy(src, dst);
 
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
-		{
 		foo = rand() % 3;	/* mmmm pas tres bon :( */
-		switch (foo)
+		switch (foo) {
-			{
 			case 0:
 				Image_plot_channel(dst, 'r', x, y, gris);
 				Image_plot_channel(dst, 'g', x, y, gris);

Lib/sobel4.c

@@ -9,8 +9,7 @@
 #include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
-int
+int Image_filtre_Sobel_4(Image_Desc *src, Image_Desc *dst, int rotation)
-Image_filtre_Sobel_4(Image_Desc *src, Image_Desc *dst, int rotation)
 {
 static	int	Sobel[] =
 	{
@@ -23,6 +22,8 @@ int	filtre[11], foo;
 Image_Desc	*tmp[4];
 int		x, y, r, g, b;
 
+fprintf(stderr, ">>> %s ( %p %p  %d )\n", __func__, src, dst,rotation);
+
 memcpy(filtre, Sobel, 11*sizeof(int));
 
 for (foo=0; foo<4; foo++) {
@@ -50,7 +51,6 @@ for (x=0; x<src->width; x++) {
 		dst->Bpix[y][x] = b;
 		}
 	}
-
 dst->modified   = 1;
 
 for (foo=0; foo<4; foo++) {

Lib/tele_2.c

@@ -123,13 +123,13 @@ xmax = src->width - w;		ymax = src->height - h;
 ox = (src->width % w) / 2;
 oy = (src->height % h) / 2;
 #if DEBUG_LEVEL
-fprintf(stderr, "%s : offsets = %d %d\n", __func__, ox, oy);
+fprintf(stderr, "%s : offsets = %d & %d\n", __func__, ox, oy);
 #endif
 Image_clear(dst, grey, grey, grey);
 
-for (x=ox; x<xmax; x+=w) {
+for (x=ox; x<(xmax-ox); x+=w) {
 	zone.x = x + (w/2);
-	for (y=oy; y<ymax; y+=h) {
+	for (y=oy; y<(ymax-oy); y+=h) {
 		zone.y = y + (h/2);
 		r = src->Rpix[y][x] & 0xfe;
 		g = src->Gpix[y][x] & 0xfe;

Lib/testbmp.c

@@ -19,6 +19,8 @@ int		w;
 Image_Desc 	*img;
 char		filename[100], chaine[110];
 
+fprintf(stderr, "k is %d in %s\n", k, __func__);
+
 Image_load_fnt8x8("libimage.fonte", NULL, 0);
 
 for (w=160; w<180; w++)

Lib/testtga.c

@@ -22,7 +22,9 @@ int		foo;
 
 fprintf(stderr, ">>> %s ( '%s' ) \n", __func__, filename);
 
+#if 0
 foo = try_to_read_a_jpeg_file(filename, &destimg);
+#endif
 
 return FULL_NUCKED;
 }
@@ -30,7 +32,7 @@ return FULL_NUCKED;
 int main(int argc, char *argv[])
 {
 char	*fichier;
-int	foo;
+int	foo, idx;
 
 printf("\n==========  TestTga  %s  %s  ==========\n", __DATE__, __TIME__);
 Image_print_version(2);
@@ -39,8 +41,7 @@ Image_print_version(2);
 Image_print_sizeof_structs("tth was here");
 #endif
 
-if (argc != 2)
+if (argc != 2) {
-	{
 	printf("no args, using the testfile\n");
 	fichier = "wou.tga";
 	}
@@ -52,13 +53,34 @@ else
 
 Image_start_chrono("Essai", 0);
 
-foo = test_du_jpeg_reader("in.jpeg");
+for (idx=0; idx<10; idx++) {
-fprintf(stderr, "    essai lecture jpeg -> %d\n", foo);
+	foo = Test_Egalisations(fichier, 0);
+	fprintf(stderr, "    essai egalisation -> %d\n", foo);
+	foo = Essai_Televisions(fichier, 10); 
+	fprintf(stderr, "    essai televisions -> %d\n", foo);
+	foo = Test_Dithering(fichier, 0);
+	fprintf(stderr, "    essai dithering   -> %d\n", foo);
+	foo = Test_des_filtres(fichier, 0);
+	fprintf(stderr, "    essai filtres     -> %d\n", foo);
+	foo = Test_RGBmask(fichier);
+	fprintf(stderr, "    essai rgb mask    -> %d\n", foo);
+	foo = Test_Classif(fichier, 0);
+	fprintf(stderr, "    essai classif     -> %d\n", foo);
+	foo = Test_des_warpings(fichier, 0);
+	fprintf(stderr, "    essai warping     -> %d\n", foo);
+	foo = Essai_color_2_map(fichier, idx);
+	fprintf(stderr, "    essai col2map     -> %d\n", foo);
+	
 
+	fprintf(stderr, "\n*************** %s: fin passe %d ******\n\n",
+						argv[0], idx);
+	}
 
 #if 0
-foo = Test_Dithering(fichier, 17);
+
-fprintf(stderr, "essai dithering -> %d\n", foo);
+
+foo = test_du_jpeg_reader("in.jpeg");
+fprintf(stderr, "    essai lecture jpeg -> %d\n", foo);
 
 Test_des_patterns("/tmp/pattt", 0, 0);
 foo = Essai_des_jauges(fichier, 17);
@@ -74,6 +96,7 @@ Test_des_warpings(fichier, 17);
 
 foo = Essai_des_Combines(fichier, 17);
 fprintf(stderr, "essai combine -> %d\n", foo);
+
 foo = Test_Dithering(fichier, 17);
 Essai_des_Contrastes(fichier, 0);
 

Lib/text0.c

@@ -220,7 +220,8 @@ posx = x;	posy = y;
 for (foo=0; foo<t_texte; foo++)	{
 	octet = ptrtxt[foo];
 	if (posx > (im->width-8)) {
-		fprintf(stderr, "can't plot char '%c' at x=%d\n", octet, posx);
+		fprintf(stderr, "%s: can't plot char '%c' at x=%d\n", 
+					__func__, octet, posx);
 		break;
 		}
 	Image_trace_caractere_2(im, priv_fonte, posx, posy, octet, paper, ink);
@@ -259,23 +260,19 @@ if ( (code < 0) || (code > 255)) {
 
 paper.r = paper.g = paper.b = 0;
 ink.r = ink.g = ink.b       = 255;
-
 rect.w = kx, rect.h = ky;
 
 /*
  *			NEED BOUNDARY CHECK !
  */
 
-for (foo=0; foo<8; foo++)		/* 8 scan lines */
+for (foo=0; foo<8; foo++) {		/* 8 scan lines */
-	{
 	octet = priv_fonte[(code*8)+foo];
 	rect.y = (foo * ky) + y;
-	for (bar=0; bar<8; bar++)
+	for (bar=0; bar<8; bar++) {
-		{
 		rect.x = (bar * kx) + x;
 		rect.x = ((8-bar)*kx) + x;
-		if (octet & 1)
+		if (octet & 1) {
-			{
 			Image_paint_rect(im, &rect, 255, 198, 0);
 			Image_draw_rect(im, &rect, 0, 0, 80);
 			}

Lib/tga.c

@@ -12,7 +12,7 @@
 #include  "../tthimage.h"   
 
 /*::------------------------------------------------------------------::*/
-#define LIBTGA_VERSION   "0.2.42"
+#define LIBTGA_VERSION   "0.2.43"
 
 typedef struct {
         uint8_t   text_size;
@@ -27,6 +27,9 @@ typedef struct {
 
         } Tga_file_header;
 /*::------------------------------------------------------------------::*/
+/*
+ *
+ */
 int Image_TGA_write_header(FILE *fp, Tga_file_header *head)
 {
 fwrite (&head->text_size, 1, 1, fp);
@@ -423,6 +426,8 @@ return OLL_KORRECT;
 /* new 1er mai 2007 (la france qui bosse tout le temps) */
 int Image_TGA_show_header(char *filename, int flag)
 {
+(void)flag;				/* WARNING KILLER */
+
 FILE			*fp;
 Tga_file_header		header;
 int			foo;
@@ -443,7 +448,7 @@ if (foo) {
 foo = Image_TGA_print_header(&header);
 if (foo)
 	{
-	;
+	fprintf(stderr, "%s: something is wrong\n", __func__);
 	}
 
 return FUNC_NOT_FINISH;

Lib/tiff.c

@@ -0,0 +1,11 @@
+/*
+ *		TIFF
+ *
+ * new Sun Jul 28 10:57:00 UTC 2024
+
+ */
+
+#include  <stdio.h>
+
+/*::------------------------------------------------------------------::*/
+/*::------------------------------------------------------------------::*/

Lib/tools.c

@@ -28,6 +28,9 @@ printf("%c\r", batons[foo&0x03]);	fflush(stdout);
 /*::------------------------------------------------------------------::*/
 /*
  *	I think that the 'chrono' system is full broken
+ *
+ *  You have to look at 'functions.c' for more timing functions.
+ *
  */
 #define NB_CHRONOS	42
 

Lib/utility.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+SRC="testtga.c essais.c operat.c image.c effects.c tele_2.c calculs.c"
+SRC="$SRC dither.c television.c rgbmask.c sobel4.c tga.c patterns*.c"
+echo $SRC ; echo
+
+FLOW="cflow.txt"
+
+cflow --depth=5 -o $FLOW -m main --number $SRC
+
+less $FLOW

Paramakes.mk

@@ -14,12 +14,13 @@ HTML_DIR=$(DESTDIR)/html
 #	pour tracer plein de trucs:   -DDEBUG_LEVEL=1
 #	if IMGCOMMENT, the image comment is written to the TGA file,
 #		but this files can't be loaded by Xv...
+#
 #	pour coredumper dans les situations graves: -DABORT=1
 #
 # 		use -Wmissing-prototypes ?
 
 LIBIMG_OPT=-DFORCE_ABORT=0 -DDEBUG_LEVEL=0 -DIMGCOMMENT=0
-CC_OPTS=-Wall -W -g -ansi -O0 -fPIC -no-pie
+CC_OPTS=-Wall -W -g -ansi -O1 -fPIC -no-pie
 CC_HACKS=-DNEED_ALLOCA_H 
 
 CFLAGS= $(CC_OPTS)			\

Tests/README.md

@@ -1,14 +1,20 @@
-# Some useless tests
+# Some useless tests ?
 
-Tester, c'est douter.
+<u>Tester, c'est douter.</u>
 
 ## État des lieux
 
-Pas grand chose.
+Pas grand chose pour le moment. Mais comme j'utilise régulièrement
+et depuis très longtemps cet amas de fonctions, on peut dire que
+les tests sont fait *in-vivo* sans formalisme formalisé. 
 
 Allez quand même voir `config.sh` et `functions.sh` pour avoir une idée
 du désastre actuel. Il reste beaucoup de choses à faire.
 
 ## Mais encore ?
 
-Dans le répertoire `Lib/` il y a un `essais.c` assez prometteur.
+Dans le répertoire `Lib/` il y a un `essais.c` assez
+[prometteur](../Lib/essais.c) et en constante évolution.
+Il manque à son [driver](../Lib/testtga.c) une gestion plus
+fluide de la sélection
+des essais à faire tourner.

Tests/frames/keep_this_dir_please.txt

@@ -0,0 +1,2 @@
+
+this directory is for temporary files made from tests.

Tests/t_recurse.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -e
+
+source="dauphine2.tga"
+if [ $# -eq 2 ] ; then
+	source="$1"
+fi
+
+identify $source ; echo
+
+rm -f frames/R*.tga
+
+maxidx=250
+
+for idx in $(seq 0 4 $maxidx)
+do
+
+	dst=$(printf "frames/R%03d.tga" $idx)
+	coef=$(( $maxidx - $idx ))
+	echo "======>  "$dst  "    coef " $coef
+
+	../Tools/tga_effects $source recurse $dst $coef
+
+done
+
+convert -delay 10 frames/R*.tga recurse.gif
+wc -c recurse.gif

Tools/.gitignore

@@ -4,3 +4,7 @@
 
 tga_extract
 tga_to_text
+tga_plothisto
+tga_plotmap
+tga_resize
+tga_fractales

Tools/Makefile

@@ -13,7 +13,8 @@ all:	genplot2						\
 	tga_combine tga_export tga_alpha tga_extract		\
 	tga_television tga_dither tga_applymap tga_makehf15	\
 	tga_mires tga_incrust tga_pattern tga_equalize		\
-	tga_to_text
+	tga_to_text tga_resize tga_plotmap tga_plothisto	\
+	tga_fractales
 
 # 'tga_info.c' do not compile yet
 
@@ -29,6 +30,22 @@ genplot2:	genplot2.c $(DEPS) fonctions.o
 
 #-----------------------------------------------------------------
 
+fractales.o: fractales.c fractales.h Makefile
+	gcc $(CFLAGS) -c $< 
+
+tga_fractales:	tga_fractales.c $(DEPS) fractales.o fonctions.o
+	gcc $(CFLAGS) $< fractales.o ../libtthimage.a fonctions.o 	\
+			 -lm -o $@
+
+tga_resize:	tga_resize.c $(DEPS) fonctions.o
+	gcc $(CFLAGS) $< ../libtthimage.a fonctions.o -lm -o $@
+
+tga_plotmap:	tga_plotmap.c $(DEPS) fonctions.o
+	gcc $(CFLAGS) $< ../libtthimage.a fonctions.o -lm -o $@
+
+tga_plothisto:	tga_plothisto.c $(DEPS) fonctions.o
+	gcc $(CFLAGS) $< ../libtthimage.a fonctions.o -lm -o $@
+
 tga_to_text:	tga_to_text.c $(DEPS) fonctions.o
 	gcc $(CFLAGS) $< ../libtthimage.a fonctions.o -lm -o $@
 
@@ -81,8 +98,8 @@ tga_extract:	tga_extract.c $(DEPS) fonctions.o
 	gcc $(CFLAGS) $< ../libtthimage.a fonctions.o -lm -o $@
 
 
-# tga_info:	tga_info.c $(DEPS) fonctions.o
+tga_info:	tga_info.c $(DEPS) fonctions.o
-#	gcc $(CFLAGS) $< ../libimage.a fonctions.o -lm -o $@
+	gcc $(CFLAGS) $< ../libimage.a fonctions.o -lm -o $@
 
 tga_pattern:	tga_pattern.c $(DEPS) fonctions.o
 	gcc $(CFLAGS)  $< ../libtthimage.a fonctions.o -lm -o $@

Tools/README.md

@@ -14,7 +14,7 @@ Usage:
         tga_filtres <src.tga> FILTR <dst.tga> [p1] ... [pn]
 -+- This is the `tthimage' library v0.4.50 (dwtfywl 2022) tTh
   commande  | type arg |  explication
-------------+----------+------------------------------------
+------------+----------+------------------------------
  liss2x2    |          |  lissage 2x2
  hipass     |          |
  lopass     |          |
@@ -31,7 +31,7 @@ La colonne du milieu indique le type des paramètres :
 ## tga_alpha
 
 Manipulation du canal alpha (la transparence), lequel canal
-est globalement mal géré par l'ensemble de libtthimage.
+est globalement mal géré par l'ensemble de la libtthimage.
 
 ## tga_applymap
 
@@ -40,13 +40,19 @@ logiciel de fractales sous ms-dos :
 [Fractint](https://fractint.org/). Quelques exemples de
 ces fichiers sont dans le répertoire `Datas/` du projet.
 
+Vous rencontrerez parfois des messages d'erreur comme
+« *color map is to big* » ou « *only 97 entries in foo.map* ».
+Pas d'inquiétude, tout va bien se passer.
+Dans le premier cas, les lignes en excédent sont ignorées,
+et dans le second, les valeurs manquantes sont mises au noir.
+
 La gestion de la ligne de commande est désastreuse. **À REFAIRE**
 
 ## tga_cadre
 
-Pas mal de façons de mettre un cadre sur l'image.
+Il existe pas mal de façons de mettre un cadre sur l'image,
-Niveau de kitchitude assez élevé.
+avec un niveau de kitchitude assez élevé.
-Paramètres mal documentés.
+Les paramètres sont mal documentés.
 
 ## tga_combine
 
@@ -54,9 +60,9 @@ Paramètres mal documentés.
 Usage:
         tga_combine s1.tga s2.tga MODE d.tga [PARAMS]
 ```
-
 Il existe plein de façon de combiner deux images, la commande
-`testtga list` vous les fera découvrir, la cinquième va vous étonner.
+`tga_combine list` vous les fera découvrir, la cinquième va vous étonner.
+Les paramètres sont mal documentés.
 
 ## tga_dither
 
@@ -72,13 +78,24 @@ Attendu avec impatience, il aura le support complet des PNG. Un jour...
 
 ## tga_filtres
 
+UTSL : [tga_filtres.c](caractère \textbf{invisible})
+
 ## tga_incrust
 
 ## tga_makehf15
 
+Pour les POViste acharnés. De façon étrange,
+[Povray](https://povray.org/) a choisi de stocker des
+champs d'altitude dans les images Targa, en n'utilisant que
+15 bits pour la valeur.
+
 ## tga_to_text
 
-Mis au point pour les imports dans d'autres langages.
+Mis au point pour les imports dans d'autres langages,
+comme Awk, Fortran ou R. Chaque ligne du fichier généré
+contient cinq champs : x, y, r, g, b.
+
+Attention, il peut vite générer d'énormes fichiers.
 
 ## tga_mires
 
@@ -91,19 +108,68 @@ vraiment trop nulle...
 
 ## tga_remap
 
+Usage:    `tga_remap M <src.tga> <color.map> <dst.tga>`
+
+Le paramètre `M` peut prendre les valeurs 0, 1, 2, 11, 12 ou 13.
+Je ne sais plus à quoi ça correspond.
+
 ## tga_television
 
 ## tga_tools
 
 Celui ci est très utile pour la recherche de problèmes ou l'automatisation
-de certaines tâches. Exemple :
+de certaines tâches. Un exemple rapide :
 
 ```
-tth@konrad:~/Devel/libtthimage$ tga_tools getdimweb mire.tga 
+tth@redlady:~/Devel/libtthimage$ tga_tools getdimweb foo.tga 
-width=512 height=512
+width=640 height=480
-tth@konrad:~/Devel/libtthimage$ 
+tth@redlady:~/Devel/libtthimage$ tga_tools getdimpov foo.tga 
+ -w640 -h480
+tth@redlady:~/Devel/libtthimage$ 
 ```
 
+###  version
+###  surface
+###  getdims, getdimx, getdimpov, getdimweb
+renvoie une chaine de caractère donnant les dimensions de l'image
+en différents formats.
+###  width, height
+renvoie chacune des deux dimensions.
+###  grminmax
+###  message 
+Flags: un entier. Si non nul, change l'encre et le papier pour
+d'autres valeurs. La chaine de caractère doit être (sjmsb) encodée
+en CP-850, voire même comme celles du Locomotive du CPC.
+
+###  structs
+
+Affichage d'information (boutisme, taille des structures) qui ne
+seront utiles qu'aux codeurs.
+```
+tth@redlady:~/Devel/libtthimage/Tools$ ./tga_tools structs
+petit  =       1234  ->   34 12
+grand  =   12345678  ->   78 56 34 12 00 00 00 00
+basic types    : short=2 int=4 long=8 ptr=8
+Image_Desc     :   1296
+Image_Rect     :     24
+RGBA           :     16
+A_BitPlane     :    128
+RGB_map        :   1624
+Image_Point    :      8
+```
+
+###  header
+###  timestamp
+###  prhisto
+
+Calcul et affichage en mode texte de l'histogramme d'une image.
+Un exemple d'utilisation avec gnuplot serait le bienvenu.
+
+###  tag7
+###  environ
+###  mk_rgb
+###  mk_hgrad
+
 ## genplot2
 
 Outil de tracé pseudo-générique et farci de bugs. *WIP ME HARDLY !*

Tools/fractales.c

@@ -0,0 +1,384 @@
+/*
+			fractales.c
+			===========
+
+     *....................................................*
+     .        warning, this is a 'work in progress'       .
+     .                                                    .
+     .        don't trust prototypes for building         .
+     .        serious applications...                     .
+     *....................................................*
+
+*/
+
+#include	<stdio.h>
+#include	<stdlib.h>
+#include	<math.h>
+#include	<time.h>
+
+#include        <tthimage.h>
+
+#include	"fractales.h"
+
+/*::------------------------------------------------------------------::*/
+void Image_fractales_print_version(int flag)
+{
+printf("*** Fractales (%s) v 0.0.12\n", __FILE__);
+if (flag)
+    {
+    printf("\tcompiled %s , %s\n", __DATE__, __TIME__);
+    }
+}
+/*::------------------------------------------------------------------::*/
+/*
+ *	fonction de comparaison de deux variables 'double'
+ */
+int	compare_double(double a, double b)
+{
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ *	cette fonction a été repompé (sans honte :) du livre de
+ *	Roger T. Stevens, "Fractal Programming in C" éditée par
+ *	M&T Books.
+ *	Ceci dit, elle est un peu trop monolithique, puisque l'équation
+ *	à résoudre est codée en dur.
+ */
+int Newton_0(Image_Desc *im, int maxiter)
+{
+int	col, row, i;
+double	dcol, drow;
+double	Xmax, Xmin, Ymax, Ymin;
+double  deltaX, deltaY, denom;
+double	X, Y, Xsquare, Ysquare, Xold, Yold;
+
+Xmax = Ymax = 3.5;	Xmin = Ymin = -3.5;
+deltaX = (Xmax-Xmin)/(double)im->width;
+deltaY = (Ymax-Ymin)/(double)im->height;
+
+for (col=0; col<im->width; col++)
+	{
+	dcol = (double)col;
+	for (row=0; row<im->height; row++)
+		{
+		drow = (double)row;
+		X = Xmin + dcol * deltaX;
+		Y = Ymin + drow * deltaY;
+		Xsquare = 0.0;
+		Ysquare = 0.0;
+		Xold = Yold = 42.0;
+		for (i=0; i<maxiter; i++)
+			{
+			Xsquare = X * X;
+			Ysquare = Y * Y;
+			denom = 3*((Xsquare-Ysquare)*(Xsquare-Ysquare) +
+				4*Xsquare*Ysquare);
+			if (denom < 0.0000001)
+				denom = 0.0000001;
+
+			X = .6666667*X + (Xsquare - Ysquare)/denom;
+			Y = .6666667*Y + 2*X*Y/denom;
+			if ((Xold==X) && (Yold==Y))
+				break;
+			}		/* finbo sur maxiter */
+
+		if (X > 0)
+			{
+			Image_plotRGB(im, col, row, 0, 0, 0);
+			}
+		else
+			{
+			if (Y > 0)
+				Image_plotRGB(im, col, row, 255, 0, 0);
+			else
+				Image_plotRGB(im, col, row, 0, 0, 255);
+			}
+		}
+	if (0 == col%5)
+		fprintf(stderr, "newton 0: col %5d / %5d\r", col, im->width);
+	}
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/
+/*
+ * C'est pas encore fini ce truc ?
+ */
+int GingerBreadMan(Image_Desc *im, int maxiter)
+{
+double	x1, y1, x2, y2;
+int	iter;
+
+x1 = 10.0;
+y1 = 0.333;
+
+for (iter=0; iter<maxiter; iter++)
+	{
+	x2 = 1.0 - y1 + abs(x1);
+	y2 = x1;
+
+	printf("%9g  %9g\n", x2, y2);
+
+	x1 = x2;
+	y1 = y2;
+	}
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/
+/*
+	En fait, il faudrait travailler sur deux images...
+*/
+int Image_Random_Walker_0(Image_Desc *im, Image_Desc *dst,
+					int nbpass, int nbsteps)
+{
+int	pass, step, foo;
+int	x, y, ra, ga, ba, rb, gb, bb;
+
+if ( (foo=Image_compare_desc(im, dst)) )
+    {
+    fprintf(stderr, "Random_Walker_0: images are differents %d\n", foo);
+    return foo;
+    }
+
+for (pass=0; pass<nbpass; pass++)
+	{
+	x = rand() % im->width;
+	y = rand() % im->height;
+
+	ra = Image_R_pixel(im, x, y);
+	ga = Image_G_pixel(im, x, y);
+	ba = Image_B_pixel(im, x, y);
+
+	/* printf("\tP%d\t\tX%d\tY%d\t%d,%d,%d\n", pass, x, y, ra, ga, ba); */
+
+	for (step=0; step<nbsteps; step++)
+		{
+		x += (rand()%3)-1;
+		if (x<0)		x += im->width;
+		if (x>=im->width)	x -= im->width;
+		y += (rand()%3)-1;
+		if (y<0)		y += im->height;
+		if (y>=im->height)	y -= im->height;
+
+		rb = Image_R_pixel(im, x, y);
+		gb = Image_G_pixel(im, x, y);
+		bb = Image_B_pixel(im, x, y);
+
+		Image_plotRGB(dst, x, y,
+			(ra+rb+rb)/3, (ga+gb+gb)/3, (ba+bb+bb)/3);
+		}
+	}
+
+return 0;
+}
+
+/*::------------------------------------------------------------------::*/
+
+#define  XMIN	(-1.5)
+#define  XMAX	(1.5)
+#define  YMIN	(-1.5)
+#define  YMAX	(1.5)
+
+int	Image_Julia_0_0(Image_Desc *im, RGB_map *pmap, int fuzz,
+						double cx, double cy)
+{
+int	col, row;
+double	deltaX, deltaY, dx, dy, x2, y2;
+long	debut, fin;
+int	iter, r, g, b, maxiter;
+
+debut = time(NULL);
+
+fprintf(stderr, "Julia_0_0: %dx%d\n", im->width, im->height);
+
+deltaX = (XMAX - XMIN) / im->width;
+deltaY = (YMAX - YMIN) / im->height;
+
+maxiter = 0;
+
+/*
+ *	si pas de palette définie, en créer une ? 
+ */
+for (row=0; row<im->height; row++)
+	{
+	dy = YMIN + (double)row * deltaY;
+
+	for (col=0; col<im->width; col++)
+		{
+#if DEBUG_LEVEL
+		printf("%5d  %5d     ", row, col);
+#endif
+
+		dx = XMIN + (double)col * deltaX;
+
+		iter = 0;
+		x2 = y2 = 0.0;
+
+		while (	(iter < fuzz) &&
+			((x2 + y2) < 4.0) )
+			{
+			x2 = dx * dx;
+			y2 = dy * dy;
+			dx = 2 * dx * dy + cx;
+			dy = x2 - y2 + cy;
+			iter++;
+			}
+
+		if (iter > maxiter)
+			maxiter = iter;
+
+		if (iter >= fuzz)
+			{
+			r = g = b = 255;
+			}
+		else
+			{
+			r = pmap->red[iter%pmap->nbre];
+			g = pmap->green[iter%pmap->nbre];
+			b = pmap->blue[iter%pmap->nbre];
+			}
+
+		Image_plotRGB(im, col, row, r, g, b);
+		
+#if DEBUG_LEVEL
+		printf("  %3d \r", iter);
+#endif
+		}
+	}
+
+fin = time(NULL);
+
+printf("duree du calcul: %ld secondes, maxiter: %d\n", fin-debut, maxiter);
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/
+
+#define  XA    -2.0
+#define  XB     2.0
+#define  YA    -2.0
+#define  YB     1.3
+
+int Image_Mandelbrot_0(Image_Desc *image, int maxiter)
+{
+int         Y, X;
+int         r, g, b;
+double      zr, zi, fx, fy, real, imag, fiter, dist2;
+long        debut, fin, temps;         /* pour chronometrer */
+int         iter, out, foo;
+double      tmpr, tmpi;
+
+debut = time(NULL);
+
+out = 0;
+
+for (Y=0; Y<image->height; Y++)
+    {
+    fprintf(stderr, "ligne %4d sur %d\r", Y, image->height);
+    fy = (double)Y;
+    real = ( fy / (double)image->height * (YB-YA) ) + YA;
+
+    for (X=0; X<image->width; X++)
+        {
+        fx = (double)X;
+        imag = ( fx / (double)image->width * (XB-XA) ) + XA;
+
+        iter = 0;
+        zr = zi = 0.0;
+
+        do
+            {
+            iter++;
+
+            dist2 = zr*zr + zi*zi;
+            if (dist2 > 4.0)
+                {
+                out++;
+                break;
+                }
+
+	    /*
+             *  calculer le mandelbrot
+             *  ----------------------
+             *      la formule est:
+             *      z0 = 0 + 0i
+             *      z1 = z0^2 + c;
+             *      ...
+	     */
+            tmpr = zr*zr - zi*zi;
+            tmpi = 2.0 * zr * zi;
+
+            zr = tmpr + real;
+            zi = tmpi + imag;
+
+            } while (iter < maxiter);
+
+        fiter = (double)iter / (double)maxiter;
+
+        Image_color_x(zr, zi, &r, &g, &b);
+        Image_plotRGB(image, X, Y, r, g, b);
+
+        }
+
+    fflush(stderr);
+    }
+
+fin = time(NULL);
+
+temps = fin - debut;
+if (temps < 500)
+    {
+    foo = 's';
+    }
+else
+    {
+    foo = 'm';
+    temps /= 60;
+    }
+
+printf("\nMandelbrot_0: temps d'execution = %ld %c\n", temps, foo);
+printf("Mandelbrot_0: nombre de points dehors = %d\n", out);
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/
+int Lorenz_Orbits(Image_Desc *img, int iters,
+				double a, double b, double c, double dt)
+{
+int		pass;
+double		dx, dy, dz, dxp, dyp, dzp;
+FILE		*fp;
+
+if (NULL == (fp=fopen("lorenz.dat", "w"))) {
+	perror("lorenz datafile");
+	exit(1);
+	}
+
+fprintf(stderr, "%s ( %p %d / %f %f %f %f )\n", __func__, img, iters,
+				a, b, c, dt);
+
+dx = dy = dz = 0.0001;
+
+for (pass=0; pass<iters; pass++) {
+
+	fprintf(fp, "%6d  %8f %8f %8f\n", pass, dx, dy, dz);
+
+	dxp = dx - (a*dx + a*dy) * dt;
+	dyp = dy + (b*dx - dy - dz*dz) * dt;
+	dzp = dz - (c*dz + dx*dy) * dt;
+
+	dx = dxp, dy = dyp, dz = dzp;
+	}
+
+fclose(fp);
+
+return 42;
+}
+/*::------------------------------------------------------------------::*/
+			/*
+			 * et un PopCorn ?
+			 */
+/*::------------------------------------------------------------------::*/

Tools/fractales.h

@@ -0,0 +1,25 @@
+/*
+			fractales.h
+			-----------
+   *....................................................*
+   .        warning, this is a 'work in progress'       .
+   .        don't trust prototypes for building         .
+   .        serious applications...                     .
+   *....................................................*
+
+
+*/
+
+void Image_fractales_print_version(int flag);
+
+int GingerBreadMan(Image_Desc *im, int maxiter);
+
+int Image_Random_Walker_0(Image_Desc *im, Image_Desc *dst,
+						int nbpass, int nbsteps);
+int Image_Julia_0_0(Image_Desc *, RGB_map *, int, double, double);
+int Image_Mandelbrot_0(Image_Desc *image, int maxiter);
+
+int Newton_0(Image_Desc *im, int maxiter);
+
+int Lorenz_Orbits(Image_Desc *img, int iters,
+				double a, double b, double c, double dt);

Tools/tga_2x2contrast.c

@@ -0,0 +1,58 @@
+/*
+		2x2 contrast enhancer
+		---------------------
+
+		:::::::::::::::::::::::::::::::::::::::::
+		:::::: NEED ACCURATE DOCUMENTATION ::::::
+		:::::::::::::::::::::::::::::::::::::::::
+*/
+
+#include  <stdio.h>
+#include  <stdlib.h>
+
+#include  "tga_outils.h"
+
+/*::------------------------------------------------------------------::*/
+void usage(void)
+{
+fprintf(stderr, "* tga_2x2contrast v 0.18 [%s] %s\n",
+				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
+fprintf(stderr, "Usage:\n\ttga_2x2contrast <src.tga> <dst.tga>\n");
+Image_print_version(0);
+exit(5);
+}
+/*::------------------------------------------------------------------::*/
+
+int main(int argc, char *argv[])
+{
+Image_Desc	*src, *dst;
+int		foo;
+
+dump_command_line(argc, argv, 0);
+
+if (argc != 3)
+	usage();
+
+if ( (src=Image_TGA_alloc_load(argv[1])) == NULL )
+	{
+	fprintf(stderr, "tga_2x2contrast: can't load \"%s\" ...\n", argv[2]);
+	exit(1);
+	}
+
+if ( (dst=Image_clone(src, 1)) == NULL )
+	{
+	exit(1);
+	}
+
+foo = Image_2x2_contrast(src, dst);
+
+if (foo)
+	{
+	fprintf(stderr, "tga_2x2contrast: %d / %s\n", foo, Image_err2str(foo));
+	}
+
+foo = Image_TGA_save(argv[2], dst, 0);
+
+exit (0);
+}
+/*::------------------------------------------------------------------::*/

Tools/tga_effects.c

@@ -442,7 +442,7 @@ switch (commande)
 	}
 
 if (foo) {
-	fprintf(stderr, "%s: return code is %d\n", __FILE__, foo);
+	/* fprintf(stderr, "%s: return code is %d\n", __FILE__, foo); */
 	Image_print_error(argv[0], foo);
 	}
 

Tools/tga_equalize.c

@@ -42,7 +42,7 @@ mot_clef mots_clef[] =
 /*::------------------------------------------------------------------::*/
 void usage()
 {
-fprintf(stderr, "* tga_equalize v 0.0.24 [%s]  (dwtfywl) tonton Th\n",
+fprintf(stderr, "* tga_equalize v 0.0.25 [%s]  (dwtfywl) tonton Th\n",
 					TGA_OUTILS_VERSION);
 fprintf(stderr, "  compiled %s at %s\n", __DATE__, __TIME__);
 fprintf(stderr, "usage:\n\ttga_equalize avant.tga mode apres.tga [params]\n");
@@ -129,6 +129,7 @@ switch (commande)
 
 
 	default:
+		fprintf(stderr, "unexpected command #%d\n", commande);
 		foo=-1;
 		break;
 	}

Tools/tga_fractales.c

@@ -0,0 +1,128 @@
+/*
+		FRACTALES
+		---------
+
+	Il reste beaucoup de travail sur cet outil:
+
+	 - plasma
+	 - popcorn
+	 - newton: oct 2003, c'est en route. janv 2010 pas fini.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include  "tga_outils.h"
+#include  "fractales.h"
+
+/*::------------------------------------------------------------------::*/
+#define		MANDEL0		1
+#define		JULIA00		2
+#define		GINGER		3
+#define		NEWTON0		10
+#define		NEWTON1		11
+#define		LORENZ0		12
+
+mot_clef mots_clef[] =
+{
+{ "ginger",	GINGER,		"ii",	"width & height"	},
+{ "julia00",	JULIA00,	"ii",	"width & height"	},
+{ "mandel0",	MANDEL0,	"ii",	"width & height"	},
+{ "newton0",	NEWTON0,	"ii",	"width & height"	},
+{ "lorenz0",    LORENZ0,	"ii",   "W & H"			},
+{ NULL,		0,		NULL,	NULL			}
+};
+
+/*::------------------------------------------------------------------::*/
+void usage(int flag)
+{
+Image_fractales_print_version(flag);
+fprintf(stderr, "usage:\n\ttga_fractales type nom.tga [params]\n");
+if (flag)
+	{
+	Image_print_version(1);
+	liste_mots_clefs(mots_clef, 42);
+	}
+exit(1);
+}
+/*::------------------------------------------------------------------::*/
+/*
+ *	argv[1]:	type fractale
+ *	argv[2]:	nom fichier.tga
+ */
+#define FIRST_PAR  3
+int main (int argc, char *argv[])
+{
+Image_Desc	*dst;
+int		foo, width, height;
+int		commande, nbargs, idx;
+RGB_map		map;
+
+dump_command_line(argc, argv, 0);
+if ( argc==2 && !strcmp(argv[1], "list") ) usage(1);
+if ( argc < 3 )		usage(0);
+
+idx = cherche_mot_clef(argv[1], mots_clef, &commande, &nbargs);
+if (idx < 0)
+	{
+	fprintf(stderr, "tga_fractales: mot-clef %s inconnu...\n", argv[1]);
+	exit(5);
+	}
+#if DEBUG_LEVEL
+fprintf(stderr, "code commande %d\n", commande);
+#endif
+
+foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PAR);
+
+dst = NULL;			/* gcc warning STFU */
+
+switch (commande)
+	{
+	case MANDEL0:
+		width = GIP(0);		height = GIP(1);
+		printf("mandelbrot 0: %dx%d\n", width, height);
+		dst = Image_alloc(width, height, 3);
+		foo = Image_Mandelbrot_0(dst, 300);
+		Image_print_error("mandelbrot 0", foo);		
+		break;
+	case JULIA00:
+		width = GIP(0);		height = GIP(1);
+		foo = Image_load_color_Map("volcano.map", "plop", &map);
+		Image_print_error("julia00: loadmap", foo);
+		dst = Image_alloc(width, height, 3);
+		Image_Julia_0_0(dst, &map, 3000, 0.333, 0.333);
+		Image_print_error("julia00: calcul", foo);
+		break;
+	case GINGER:
+		width = GIP(0);		height = GIP(1);
+		printf("ginger bread man: %dx%d\n", width, height);
+		dst = Image_alloc(width, height, 3);
+		foo = GingerBreadMan(dst, 300);
+		Image_print_error("GingerBreadMan", foo);		
+		break;
+	case NEWTON0:
+		width = GIP(0);		height = GIP(1);
+		printf("newton 0: %dx%d\n", width, height);
+		dst = Image_alloc(width, height, 3);
+		foo = Newton_0(dst, 42);
+		Image_print_error("proto Newton 0", foo);		
+		break;
+	case LORENZ0:
+		width = GIP(0);		height = GIP(1);
+		printf("lorenz 0: %dx%d\n", width, height);
+		dst = Image_alloc(width, height, 3);
+		foo = Lorenz_Orbits(dst, 3000, 5.0, 15.0, 1.0, 0.02);
+		Image_print_error("lorenz 0", foo);		
+		break;
+	default:
+		fprintf(stderr, "Cette fractale n'est pas disponible.\n");
+		exit(1);
+		break;
+	}
+
+foo = Image_TGA_save(argv[2], dst, 0);
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/

Tools/tga_incrust.c

@@ -42,7 +42,7 @@ fprintf(stderr, "* TGA incrustator  v 0.1.3 [%s] %s \n",
 				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
 fprintf(stderr, "  compiled %s at %s\n", __DATE__, __TIME__);
 
-fprintf(stderr, "usage:\n\ttga_incrust orig insert mode out\n");
+fprintf(stderr, "usage:\n\ttga_incrust <orig.tga> <insert.tga> MODE <out.tga>\n");
 
 if (flag) {
 	Image_print_version(0);

Tools/tga_plothisto.c

@@ -0,0 +1,61 @@
+/*
+	utilitaire pour plotter les histogrammes d'une image.
+	-----------------------------------------------------
+*/
+
+#include  <stdio.h>
+#include  <stdlib.h>
+
+#include  "tga_outils.h"
+
+void usage()
+{
+fprintf(stderr, "*** tga_plothisto v 0.1.3 [%s] %s\n", 
+				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
+fprintf(stderr, "\nusage: tga_plothisto image.tga histo.tga [texte]\n\n");
+Image_print_version(0);
+exit(5);
+}
+
+int main (int argc, char *argv[])
+{
+Image_Desc	*src;
+long		hr[256], hg[256], hb[256];
+int		foo;
+char		*texte;
+
+dump_command_line(argc, argv, 0);
+
+if (argc < 3)
+	{
+	/*fprintf(stderr, "argc = %d\n", argc);*/
+	usage();
+	}
+
+if ( (src=Image_TGA_alloc_load(argv[1])) == NULL )
+	{
+	fprintf(stderr, "tga_plothisto, chargement '%s' failed\n", argv[1]);
+	exit(5);
+	}
+
+foo = Image_histo_RGB(src, hr, hb, hg);
+if (foo)
+	{
+	fprintf(stderr, "tga_plothisto, calcul histogramme: %d  %s\n",
+						foo, Image_err2str(foo));
+	exit(5);
+	}
+
+if (argc == 3)		texte = argv[1];
+else			texte = argv[3];
+
+foo = Image_plot_histo(argv[2], hr, hg, hb, texte);
+if (foo)
+	{
+	fprintf(stderr, "tga_plothisto, dessin de '%s': %d  %s\n",
+					argv[2], foo, Image_err2str(foo));
+	exit(5);
+	}
+
+return 0;
+}

Tools/tga_plotmap.c

@@ -0,0 +1,64 @@
+/*
+	----------------------------------------------
+	utilitaire pour tracer une map 'a la fractint'
+	----------------------------------------------
+	     http://tth.zouh.org/libimage.html   
+	----------------------------------------------
+*/
+
+#include  <stdio.h>
+#include  <stdlib.h>
+
+#include  "tga_outils.h"
+
+/* ------------------------------------------------------------------ */
+void usage()
+{
+fprintf(stderr, "* tga_plotmap v 0.1.11 [%s] %s\n",
+				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
+fprintf(stderr, "usage:\n\ttga_plotmap colors.map graphe.tga [texte]\n\n");
+Image_print_version(1);
+exit(5);
+}
+
+#define		CLASSIC		1
+#define		PAPER		2
+#define		SQUARE		3
+
+mot_clef mots_clef[] =
+{
+{ "classic",	CLASSIC,	"", 	"classic"	},
+{ "paper",	PAPER,		"",	"papier"	},
+{ "square",	SQUARE,		"",	"square"	},
+{ NULL,		0,		"",	NULL		}
+};
+
+/* ------------------------------------------------------------------ */
+int main (int argc, char *argv[])
+{
+RGB_map		map;
+int		foo;
+
+dump_command_line(argc, argv, 0);
+
+if ((argc!=3)&&(argc!=4))		usage();
+
+foo = Image_load_color_Map(argv[1], "tga_plotmap", &map);
+if (foo)
+	{
+	fprintf(stderr, "tga_plotmap, chargement '%s': %d  %s\n",
+					argv[1], foo, Image_err2str(foo));
+	exit(5);
+	}
+
+fprintf(stderr, "map file %s have %d colors\n", argv[1], map.nbre);
+
+foo = Image_plot_Map(argv[2], &map, argc==4?argv[3]:argv[1]);
+if (foo)
+	{
+	fprintf(stderr, "tga_plotmap, dessin de '%s': %d  %s\n",
+					argv[2], foo, Image_err2str(foo));
+	}
+
+return 0;
+}

Tools/tga_resize.c

@@ -0,0 +1,145 @@
+/*
+		...............................
+		.redimensionnement d'une image.
+		...............................
+*/
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <string.h>
+
+
+#include  "tga_outils.h"
+
+/*::------------------------------------------------------------------::*/
+#define  HALF_SIZE	1
+#define  DOUBLE_SIZE	2
+#define  PERCENT	3
+#define  NEWSIZE	4
+
+mot_clef mots_clef[] =
+{
+{ "half",	HALF_SIZE,	"f",	"0:crude 1:interpolate"		},
+{ "double",	DOUBLE_SIZE,	"f",	""				},
+{ "percent",    PERCENT,	"dii",  "%%size, method, 0"		},
+{ "newsize",	NEWSIZE,	"iii",	"newW newH method"		}
+};
+/*::------------------------------------------------------------------::*/
+void usage(int flag)
+{
+fprintf(stderr, "* Tga Resize v 0.0.13 [%s] %s\n",
+				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
+
+fprintf(stderr, "usage:\n");
+fprintf(stderr, "\ttga_resize source.tga methode resultat.tga [params]\n");
+if (flag)
+	liste_mots_clefs(mots_clef, 42);
+else
+	Image_print_version(0);
+exit(5);
+}
+/*::------------------------------------------------------------------::*/
+/*
+ *	argv[1]		source.tga
+ *	argv[2]		méthode
+ *	argv[3]		destination.tga
+ */
+#define  FIRST_PARAM	4
+int main(int argc, char *argv[])
+{
+Image_Desc	*src, *dst;
+int		foo, idx;
+int		commande, nbargs, interpol;
+double		scale, scaleX, scaleY;
+int		newW, newH;
+
+dump_command_line(argc, argv, 0);
+
+if ( argc==2 && !strcmp(argv[1], "list") ) usage(1);
+if ( argc < 4)	usage(0);
+
+/*
+ *	rechercher le mot clef dans la table
+ */
+idx = cherche_mot_clef(argv[2], mots_clef, &commande, &nbargs);
+if (idx < 0)
+	{
+	fprintf(stderr, "keyword %s unknow\n", argv[1]);
+	exit(5);
+	}
+
+/*
+ *	décodage des paramètres
+ */
+foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PARAM);
+#if DEBUG_LEVEL
+fprintf(stderr, "tga_resize: ret parse parameters = %d\n", foo);
+#endif
+
+if ((src = Image_TGA_alloc_load(argv[1]))==NULL)
+	{
+	fprintf(stderr, "tga_resize: can't load '%s'\n", argv[1]);
+	exit(5);
+	}
+
+dst = NULL;	/* secure the default case */
+
+switch (commande)
+	{
+	case HALF_SIZE:
+		if ( (dst=Image_MakeHalfSize(src, GFP(0))) == NULL)
+			{
+			fprintf(stderr, "tga_resize: half: fatal error\n");
+			exit(1);
+			}
+		foo = 0;
+		break;
+
+	case DOUBLE_SIZE:
+		if ( (dst=Image_MakeDoubleSize(src, GFP(0))) == NULL)
+			{
+			fprintf(stderr, "tga_resize: double: fatal error\n");
+			exit(1);
+			}
+		foo = 0;
+		break;
+
+	case PERCENT:
+		scale = GDP(0) / 100.0;
+		interpol = GIP(1);
+#if DEBUG_LEVEL
+		printf("  scale = %f\n", scale);
+		printf("  interpol = %d\n", interpol);
+#endif
+		if ((dst = Image_new_scale(src, scale, scale, interpol))==NULL)
+			{
+			fprintf(stderr, "tga_resize: percent: fatal error\n");
+			exit(1);
+			}
+		break;
+
+	case NEWSIZE:
+		newW = GIP(0);
+		newH = GIP(1);
+		printf("new size: %d x %d\n", newW, newH);
+		scaleX = ((double)newW / (double)src->width);
+		scaleY = ((double)newH / (double)src->height);
+		printf("scales:  X %f  y %f\n", scaleX, scaleY);	
+
+		if ((dst = Image_new_scale(src, scaleX, scaleY, GIP(2)))==NULL)
+			{
+			fprintf(stderr, "tga_resize: newsize: fatal error\n");
+			exit(1);
+			}
+		break;
+	}
+
+/*
+ *	sauvons vite ce precieux resultat
+ */
+if (dst != NULL)
+	foo = Image_TGA_save(argv[3], dst, 0);
+
+return 0;
+}
+/*::------------------------------------------------------------------::*/

Tools/tga_to_text.c

@@ -11,21 +11,27 @@
 #include  "tga_outils.h"
 
 /*::------------------------------------------------------------------::*/
-
+/*
+ *	Print a textual form of a picture, so you can read it
+ *	with a software who can't read TGA files.
+ *	Exemples: Fortran or Basic code, R, the statistic
+ *	software. And maybe you cant write a shell script
+ *	to convert from TGA to PNM :)
+ */
 int printf_this_picture(Image_Desc *pic, int flag)
 {
 int		x, y,	r, g, b;
 
 if (flag) {
-	/* needed for easy import in R */
+	/* needed for easy import in Rstats */
 	printf("    X     Y      R    G    B\n");
 	}
 
 for (y=0; y<pic->height; y++) {
 	for (x=0; x<pic->width; x++) {
-		printf("%5d %5d   ", x, y);
+		printf("%5d %5d    ", x, y);
 		Image_getRGB(pic, x, y, &r, &g, &b);
-		printf("%4d %4d %4d\n", r, g, b);
+		printf("%3d %3d %3d\n", r, g, b);
 		}
 	}		
 

Tools/tga_tools.c

@@ -141,8 +141,7 @@ fprintf(stderr, "%s -> %s : %dx%d, rgb %d,%d,%d\n", __func__, fname, w, h,
 					r, g, b);
 #endif
 
-if (w < 1 || h < 1)
+if (w < 1 || h < 1) {
-	{
 	fprintf(stderr, "%s : img dims %d %d ?\n", __func__, w, h);
 	return 666;
 	}
@@ -168,8 +167,7 @@ Image_Desc	*src;
 fprintf(stderr, "timestamping '%s' to '%s' with '%s'\n", fnin, fnout, txt);
 #endif
 
-if ( (src=Image_TGA_alloc_load(fnin)) == NULL )
+if ( (src=Image_TGA_alloc_load(fnin)) == NULL )	{
-	{
 	fprintf(stderr, "tga_tools, load of '%s' failed in %s\n",
 					fnin, __func__);
 	exit(5);
@@ -207,15 +205,23 @@ if (must_be_verbose()) {
 			 __func__, fnin, fnout, txt, flag);
 	}
 
-if ( (src=Image_TGA_alloc_load(fnin)) == NULL )
+if ( (src=Image_TGA_alloc_load(fnin)) == NULL ) {
-	{
 	fprintf(stderr, "tga_tools, load of '%s' failed in %s\n",
 					fnin, __func__);
 	exit(5);
 	}
 
 foo = Image_txt1_box_0(src, txt, posx, posy, 4, &pap, &ink, 0);
-Image_TGA_save(fnout, src, 0);
+if (foo) {
+	fprintf(stderr, "err txt1_box_0 = %d\n", foo);
+	return foo;
+	}
+
+foo = Image_TGA_save(fnout, src, 0);
+if (foo) {
+	fprintf(stderr, "%s: err TGA save = %d\n", __func__, foo);
+	return foo;
+	}
 
 #if DEBUG_LEVEL
 fprintf(stderr, "%s : saving %s\n", __func__, fnout);
@@ -234,21 +240,18 @@ if (flags) {
 	fprintf(stderr, "in %s, flags must be 0\n", __func__);
 	}
 
-if ( (src=Image_TGA_alloc_load(filename)) == NULL )
+if ( (src=Image_TGA_alloc_load(filename)) == NULL ) {
-	{
 	fprintf(stderr, "tga_tools, chargement '%s' failed\n", filename);
 	exit(5);
 	}
 foo = Image_histo_RGB(src, hr, hb, hg);
-if (foo)
+if (foo) {
-	{
 	fprintf(stderr, "tga_tools, calcul histogramme: %d  %s\n",
 						foo, Image_err2str(foo));
 	exit(5);
 	}
 
-for (foo=0; foo<256; foo++)
+for (foo=0; foo<256; foo++) {
-	{
 	printf("%3d   %8ld   %8ld   %8ld\n", foo, hr[foo], hg[foo], hb[foo]);
 	}
 
@@ -260,15 +263,13 @@ int print_environ(void)
 {
 int	foo;
 char	*ptr;
-char	*noms[] = 
+char	*noms[] = {
-	{
 	NOM_VAR_ENV_VERBOSE, NOM_VAR_ENV_TIMING, "LIBIMAGE_PATH", 
 	"TTH_CONF_DIR", "LIBIMAGE_DEBUG", "BITMAP_FONTS",
 	"FIXED_SEED", ENV_DEFAULT_RGBA
 	};
 
-for (foo=0; foo<(int)(sizeof(noms)/sizeof(char *)); foo++)
+for (foo=0; foo<(int)(sizeof(noms)/sizeof(char *)); foo++) {
-	{
 	ptr = getenv(noms[foo]);
 	printf("%5d    %-25s  %s\n", foo, noms[foo], ptr);
 	}
@@ -286,8 +287,7 @@ char		buffer[100];
 fprintf(stderr, "%s:%s %s %d\n", __FILE__, __func__, fname, value);
 #endif
 
-if ( (src=Image_TGA_alloc_load(fname)) == NULL )
+if ( (src=Image_TGA_alloc_load(fname)) == NULL ) {
-	{
 	fprintf(stderr, "tga_tools, load of '%s' failed in %s\n",
 					fname, __func__);
 	exit(5);
@@ -339,16 +339,14 @@ foo = set_new_seed(42);
 fprintf(stderr, "!!! set new seed -> %d\n", foo);
 #endif
 
-if (1 == argc)
+if (1 == argc) {
-	{
 	fprintf(stderr, "* tga_tools v 0.1.33 (%s) *\n", __DATE__);
 	fprintf(stderr, "usage:\n\t%s action f.tga [params]\n", argv[0]);
 	liste_mots_clefs(commandes, 42);
 	exit(0);
 	}
 
-if (-1 == (idx=cherche_mot_clef(argv[1], commandes, &mode, &nbarg)) )
+if (-1 == (idx=cherche_mot_clef(argv[1], commandes, &mode, &nbarg)) ) {
-	{
 	fprintf(stderr, "action '%s' inconnue.\n", argv[1]);
 	exit(1);
 	}
@@ -452,7 +450,7 @@ switch(mode)
 	}
 
 if (foo) {
-	fprintf(stderr, "*** at end of %s, foo was %d\n", __func__, foo);
+	/* fprintf(stderr, "*** at end of %s, foo was %d\n", __func__, foo); */
 	}
 return 0;
 }

install.sh

@@ -15,7 +15,8 @@ cp -v Datas/*.map			$DESTDIR/share/libimage/
 liste="genplot2 tga_cadre tga_effects tga_filtres tga_remap tga_tools	\
        tga_combine tga_television tga_dither tga_applymap tga_makehf15	\
        tga_mires tga_incrust tga_pattern tga_equalize tga_alpha		\
-	tga_to_text"
+       tga_to_text tga_plotmap tga_resize tga_extract tga_2x2contrast	\
+       tga_plothisto tga_export tga_fractales"
 
 for binaire in $liste
 do

tthimage.h

@@ -4,7 +4,7 @@
 	http://la.buvette.org/devel/libimage/
 */
 #ifndef IMAGE_VERSION_STRING
-	#define IMAGE_VERSION_STRING "0.4.51 pl 85"
+	#define IMAGE_VERSION_STRING "0.4.51 pl 91"
 
 /*::------------------------------------------------------------------::*/
 /*
@@ -315,10 +315,15 @@ int Image_G_pixel(Image_Desc *img, int x, int y);
 int Image_B_pixel(Image_Desc *img, int x, int y);
 int Image_A_pixel(Image_Desc *img, int x, int y);
 
+/* Mon Aug 12 2024 : this function may be rewrited with a macro ? */
 int Image_pixel_copy(Image_Desc *s, int x, int y, Image_Desc *d, int i, int j);
 
 int Image_compare_desc(Image_Desc *a, Image_Desc *b);
 
+/*::------------------------------------------------------------------::*/
+/*	module functions.c						*/
+
+double tthi_dtime(void);
 
 /*::------------------------------------------------------------------::*/
 /*	module pixels.c							*/