.gitignore

@@ -1,9 +1,5 @@
 
 *.o
 
-libimage.a
-
 foo
 
-Lib/foo
-Lib/t_t16x24

Lib/Makefile

@@ -1,139 +0,0 @@
-#-----------------------------------------------------------------
-#
-#	The infamous    *LIBTTHIMAGE*       20 juin 2022
-#
-#-----------------------------------------------------------------
-
-include ../Paramakes.mk
-
-DEPS = ../tthimage.h Makefile
-
-STATICLIB = "../libimage.a"
-
-#-----------------------------------------------------------------
-
-basic_io.o:	basic_io.c	$(DEPS)
-bitblt.o:	bitblt.c	$(DEPS)
-
-calcluts.o:	
-calculs.o:	calculs.c	$(DEPS)
-classif.o:	classif.c	$(DEPS)
-col_xyz.o:	col_xyz.c	$(DEPS)
-combine.o:	combine.c	$(DEPS)
-combine2.o:	combine2.c	$(DEPS)
-combine3.o:	combine3.c	$(DEPS)
-combine4.o:	combine4.c	$(DEPS)
-combine5.o:	combine5.c	$(DEPS)
-combine6.o:	combine6.c	$(DEPS)
-
-dither.o:	dither.c	$(DEPS)
-dither2.o:	dither2.c	$(DEPS)
-dither3.o:	dither3.c	$(DEPS)
-dither4.o:	dither4.c	$(DEPS)
-doublesz.o:	doublesz.c	$(DEPS)
-drawing.o:	drawing.c	$(DEPS)
-
-effects.o:	effects.c	$(DEPS)
-effects2.o:	effects2.c	$(DEPS)
-effects3.o:	effects3.c	$(DEPS)
-
-filtres.o:	filtres.c	$(DEPS)
-
-halfsize.o:	halfsize.c	$(DEPS)
-
-image.o:    	image.c		$(DEPS)
-imprime.o:	imprime.c	$(DEPS)
-
-luts15bits.o:	luts15bits.c	$(DEPS)
-
-marques.o:	marques.c	$(DEPS)
-mircol.o:	mircol.c	$(DEPS)
-msglib.o:	msglib.c	$(DEPS)
-mustopen.o:	mustopen.c	$(DEPS)
-
-operat.o:	operat.c	$(DEPS)
-op2x2.o:	op2x2.c		$(DEPS)
-
-patterns.o:	patterns.c	$(DEPS)
-patterns2.o:	patterns2.c	$(DEPS)
-patterns3.o:	patterns3.c	$(DEPS)
-patterns4.o:	patterns4.c	$(DEPS)
-pht.o:		pht.c		$(DEPS)
-pixeliz.o:	pixeliz.c	$(DEPS)
-pixels.o:	pixels.c	$(DEPS)
-plotteur.o:	plotteur.c	$(DEPS)
-pov_hf15a.o:	pov_hf15a.c	$(DEPS)
-pov_hf15b.o:	pov_hf15b.c	$(DEPS)
-pov_hf15c.o:	pov_hf15c.c	$(DEPS)
-pov_hf15d.o:	pov_hf15d.c	$(DEPS)
-pov_hf15e.o:	pov_hf15e.c	$(DEPS)
-pov_hf15f.o:	pov_hf15f.c	$(DEPS)
-pov_synth.o:	pov_synth.c	$(DEPS)
-
-rgbmask.o:	rgbmask.c	$(DEPS)
-
-scale.o:	scale.c		$(DEPS)
-sobel4.o:	sobel4.c	$(DEPS)
-
-tamppool.o:	tamppool.c	$(DEPS)
-television.o:	television.c	$(DEPS)
-text0.o:	text0.c		$(DEPS)
-text1.o:	text1.c		$(DEPS)
-text16x24.o:	text16x24.c	$(DEPS)
-tga.o:		tga.c		$(DEPS)
-tools.o:	tools.c		$(DEPS)
-
-vignetize.o:	vignetize.c	$(DEPS)
-
-warp0.o:	warp0.c		$(DEPS)
-warp1.o:	warp1.c		$(DEPS)
-warp2.o:	warp2.c		$(DEPS)
-warp3.o:	warp3.c		$(DEPS)
-
-
-#-----------------------------------------------------------------
-
-OBJECTS =	basic_io.o bitblt.o					\
-		calculs.o classif.o col_xyz.o				\
-		combine.o combine2.o combine3.o combine4.o combine5.o 	\
-		dither.o dither2.o dither3.o dither4.o			\
-		doublesz.o drawing.o					\
-		effects.o effects2.o effects3.o				\
-		filtres.o						\
-		halfsize.o						\
-		image.o	imprime.o					\
-		luts15bits.o						\
-		marques.o mircol.o msglib.o mustopen.o			\
-		operat.o op2x2.o					\
-		patterns.o patterns2.o patterns3.o patterns4.o		\
-		pht.o pixeliz.o pixels.o plotteur.o			\
-		pov_hf15a.o pov_hf15b.o pov_hf15c.o pov_hf15d.o 	\
-		pov_hf15e.o pov_hf15e.o pov_hf15f.o pov_synth.o		\
-		rgbmask.o						\
-		scale.o	sobel4.o					\
-		tamppool.o television.o text0.o text1.o text16x24.o	\
-		tga.o tools.o						\
-		vignetize.o						\
-		warp0.o warp1.o warp2.o warp3.o
-
-$(STATICLIB): 	$(OBJECTS)
-	$(AR) 	vrs $@ $?
-	$(RANLIB)   $@
-
-#-----------------------------------------------------------------
-
-foo:		foo.c $(DEPS) $(STATICLIB)
-	gcc $(CFLAGS) $< $(STATICLIB) -o $@
-
-t_t16x24:	t_t16x24.c $(DEPS)  $(STATICLIB)
-	gcc $(CFLAGS) $< $(STATICLIB) -o $@
-
-#-----------------------------------------------------------------
-
-essais.o:	essais.c	$(DEPS) essais.h
-	gcc $(CFLAGS) $< -c
-
-testtga:	testtga.c $(DEPS) $(STATICLIB) essais.o
-	gcc $(CFLAGS) $< $(STATICLIB) essais.o -lm -o $@
-
-#-----------------------------------------------------------------

Lib/README.md

@@ -1,4 +0,0 @@
-# The tTh image processind library
-
-Ugly software born around 1995 on a MS-Dos 286 computer.
-

Lib/doublesz.c

@@ -1,154 +0,0 @@
-/*
-                    doublesz.c
-		----------------
-	see also: scale.c halfsize.c
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-#include   <math.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	cette fonction alloue une _nouvelle_ image
- *
- *	méthodes:
- *		0: primitive.
- *		1: semblant d'interpolation.
- *
- */
-Image_Desc *
-Image_MakeDoubleSize(Image_Desc *image, int methode)
-{
-int		largeur, hauteur, x, y, xx, yy;
-Image_Desc	*sortie;
-int		v1, v2, v3, v4;
-
-largeur = image->width * 2;
-hauteur = image->height * 2;
-sortie = Image_alloc(largeur, hauteur, image->type);
-#if DEBUG_LEVEL
-fprintf(stderr, "Image double size: %d %d -> %p\n", largeur, hauteur, sortie);
-#endif
-if ( sortie == NULL )
-	{
-	fprintf(stderr, "Image make double size: no memory\n");
-	exit(5);
-	}
-
-/*
- *	transfert de certains attributs...
- */
-sortie->modified = 0;
-sortie->errmsg = image->errmsg;		/* XXX pointeur fou ? */
-
-if (methode == 0)
-	{
-	for (x=0; x<image->width; x++)
-		{
-		xx = x * 2;
-		for (y=0; y<image->height; y++)
-			{
-			yy = y * 2;
-			Image_pixel_copy(image, x, y, sortie, xx, yy);
-			Image_pixel_copy(image, x, y, sortie, xx+1, yy);
-			Image_pixel_copy(image, x, y, sortie, xx, yy+1);
-			Image_pixel_copy(image, x, y, sortie, xx+1, yy+1);
-			}
-		}
-	}
-else
-	{
-	for (x=0; x<image->width-1; x++)
-		{
-		xx = x * 2;
-		for (y=0; y<image->height-1; y++)
-			{
-			yy = y * 2;
-
-			v1 = (image->Rpix[y])[x];
-			v2 = (image->Rpix[y])[x+1];
-			v3 = (image->Rpix[y+1])[x];
-			v4 = (image->Rpix[y+1])[x+1];
-			(sortie->Rpix[yy])[xx] = v1;
-			(sortie->Rpix[yy])[xx+1] = (v1+v2)/2;
-			(sortie->Rpix[yy+1])[xx] = (v1+v3)/2;
-			(sortie->Rpix[yy+1])[xx+1] = (v1+v2+v3+v4)/4;
-
-			v1 = (image->Gpix[y])[x];
-			v2 = (image->Gpix[y])[x+1];
-			v3 = (image->Gpix[y+1])[x];
-			v4 = (image->Gpix[y+1])[x+1];
-			(sortie->Gpix[yy])[xx] = v1;
-			(sortie->Gpix[yy])[xx+1] = (v1+v2)/2;
-			(sortie->Gpix[yy+1])[xx] = (v1+v3)/2;
-			(sortie->Gpix[yy+1])[xx+1] = (v1+v2+v3+v4)/4;
-
-			v1 = (image->Bpix[y])[x];
-			v2 = (image->Bpix[y])[x+1];
-			v3 = (image->Bpix[y+1])[x];
-			v4 = (image->Bpix[y+1])[x+1];
-			(sortie->Bpix[yy])[xx] = v1;
-			(sortie->Bpix[yy])[xx+1] = (v1+v2)/2;
-			(sortie->Bpix[yy+1])[xx] = (v1+v3)/2;
-			(sortie->Bpix[yy+1])[xx+1] = (v1+v2+v3+v4)/4;
-			}
-		}  /* finbo x */
-
-	}	/* endif */
-
-sortie->modified = 0;		
-
-return sortie;
-}
-/*::------------------------------------------------------------------::*/
-Image_Desc *
-Image_MakeDoubleSize_H(Image_Desc *image, int methode)
-{
-Image_Desc	*sortie;
-int		largeur, x, y, r, g, b;
-int		r2, g2, b2;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "*** %s is experimental. method: %d\n", __func__, methode);
-#endif
-
-largeur = image->width * 2;
-fprintf(stderr, "%s ---> %d x %d\n", __func__, largeur, image->height);
-
-sortie = Image_alloc(largeur, image->height, image->type);
-if ( sortie == NULL )
-	{
-	fprintf(stderr, "Image make double size H: no memory\n");
-	exit(5);
-	}
-
-#if DEBUG_LEVEL
-Image_dump_descriptor(sortie, "double largeur");
-#endif
-
-switch (methode)
-	{
-	case 0:
-	for (x=0; x<image->width; x++)
-		{
-		for (y=0; y<image->height; y++)
-			{
-			Image_getRGB(image, x, y, &r, &g, &b);
-			Image_plotRGB(sortie, x, y, r, g, b);
-			Image_plotRGB(sortie, x+1, y, r, g, b);
-			}
-		}
-	break;
-
-	case 1:
-	break;
-	}
-
-sortie->modified = 1;
-
-return sortie;
-}
-/*::------------------------------------------------------------------::*/

Lib/drawing.c

@@ -1,240 +0,0 @@
-/*
-		primitives graphiques premier module (back in 1999)
-		---------------------------------------------------
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-#ifndef min
-#define min(a,b) ((a)<(b)?(a):(b))
-#define max(a,b) ((a)>(b)?(a):(b))
-#endif
-/*::------------------------------------------------------------------::*/
-static int
-iSign(int a)
-{
-if (a<0)	return -1;
-if (a>0)	return 1;
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-static void symmetry(int x, int y, int xc, int yc, RGBA *g, Image_Desc *i)
-{
-int	x_start, x_end;
-int	y_start, y_end;
-
-x_start = x;		y_start = y;
-x_end = x + 1;		y_end = y + 1;
-
-Image_plotRGB(i, x+xc, y+yc, 100, 100, 100);
-
-fprintf(stderr, "sym %d %d\n", x, y);
-}
-
-/* le paramètre 'wrap' ne sert à rien */
-int
-Image_draw_circle(Image_Desc *i, int xc, int yc, int rayon, RGBA *q, int wrap)
-{
-int	x, y, d;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : centre %d %d, rayon %d\n", __func__, xc, yc, rayon);
-#endif
-
-y = rayon;
-d = 3 - 2 * rayon;
-
-for ( x=0; x<y; )
-	{
-	symmetry(x, y, xc, yc, q, i);
-
-	if (d<0)
-		{
-		d += 4 * x + 6;
-		}
-	else
-		{
-		d += 4 * (y - x) * 10;
-		--y;
-		}
-	++x;
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	l'appel a la fonction isign devrait disparaitre pour optimiser
- *	la vitesse du bouzin.
- */
-int
-Image_draw_line(Image_Desc *i, int x1, int y1, int x2, int y2, RGBA *q)
-{
-int	dx, dy, ix, iy, inc;
-int	foo, plotx, ploty, x, y;
-int	plot;
-
-#if DEBUG_LEVEL > 1
-printf("%s   %4d  %4d   ----->   %4d  %4d\n", __func__, x1, y1, x2, y2);
-#endif
-
-dx = x2 - x1;		dy = y2 - y1;
-ix = abs(dx);		iy = abs(dy);
-inc = ix<iy ? iy : ix;
-
-#if DEBUG_LEVEL > 1
-printf("d %4d %4d    i %4d %4d   ^ %4d\n", dx, dy, ix, iy, inc);
-#endif
-
-plotx = x1;
-ploty = y1;
-x = y = 0;
-
-for (foo=0; foo<=inc; ++foo)
-	{
-	x += ix;
-	y += iy;
-	plot = 0;
-	if (x > inc)
-		{
-		plot = 42;
-		x -= inc;
-		plotx += iSign(dx);
-		}
-	if (y > inc)
-		{
-		plot = 42;
-		y -= inc;
-		ploty += iSign(dy);
-		}
-	if (plot)
-		{
-		/* printf("%5d %5d %5d\n", foo, plotx, ploty ); */
-		Image_plotRGB(i, plotx, ploty, q->r, q->g, q->b);
-		}
-
-	}
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	XXX si je veux remplacer 'plotRGB' par un accès direct
- *	XXX dans les buffers, il faut soigner les controles
- */
-int
-Image_paint_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b)
-{
-int	xd, yd, xf, yf, x, y;
-
-#if DEBUG_LEVEL > 2
-fprintf(stderr, "Paint Rect : image %d x %d\n", img->width, img->height);
-Image_dump_rect(rect, "in 'paint a rect'", 0);
-#endif
-
-xd = max(0, rect->x);
-yd = max(0, rect->y);
-xf = min((img->width), (rect->x+rect->w));
-yf = min((img->height), (rect->y+rect->h));
-/* 
- *  24 Juin 2002: est-ce que le code ci-dessus a été sérieusement validé ?
- *  24 Avril 2008: NON !
- *  26 janvier 2014 : toujours non...
- */
-
-#if DEBUG_LEVEL > 2
-fprintf(stderr, "Paint Rect:   %4d < X < %4d      %4d < Y < %4d\n",
-				xd, xf,		yd, yf);
-#endif
-
-for (x=xd; x<xf; x++)
-	{
-	for (y=yd; y<yf; y++)
-		{
-		/* Image_plotRGB(img, x, y, r, g, b); */
-		(img->Rpix[y])[x] = r;
-		(img->Gpix[y])[x] = g;
-		(img->Bpix[y])[x] = b;
-		}
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	27 Juin 2001: there was an off-by-one error in this func...
- *	See also 'drawpatt.c' for others things.
- */
-int
-Image_draw_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b)
-{
-int	foo;
-int	xd, yd, xf, yf;
-
-xd = max(0, rect->x);
-yd = max(0, rect->y);
-xf = min((img->width-1), ((rect->x+rect->w)));
-yf = min((img->height-1), ((rect->y+rect->h)));
-
-#if DEBUG_LEVEL > 1
-Image_dump_rect(rect, "draw a rect", 0);
-fprintf(stderr, "Draw a Rect:   xd:%4d  yd:%4d      xf:%4d  yf:%4d\n",
-				xd, yd,		 xf, yf);
-#endif
-
-for (foo=xd; foo<xf; foo++)
-	{
-	/* if ( (rect->y >= 0) && (rect->y < img->height) ) */
-		Image_plotRGB(img, foo, rect->y, r, g, b);
-	/* if ( (rect->y+rect->h >= 0) && (rect->y+rect->h < img->height) ) */
-		Image_plotRGB(img, foo, rect->y+rect->h-1, r, g, b);
-	}
-
-for (foo=yd; foo<yf; foo++)
-	{
-	/* if ( (rect->x >= 0) && (rect->x < img->width) ) */
-		Image_plotRGB(img, rect->x, foo, r, g, b);
-	/* if ( (rect->x+rect->w >= 0) && (rect->x+rect->w < img->width) ) */
-		Image_plotRGB(img, rect->x+rect->w-1, foo, r, g, b);
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/* new 10 octobre 2008 - zone de Monredon (Betatech) */
-int
-Image_noise_rect(Image_Desc *img, Image_Rect *rect, int r, int g, int b)
-{
-int	xd, yd, xf, yf, x, y;
-
-fprintf(stderr, "%s: i=%p r=%p %d %d %d\n", __func__, img, rect, r, g, b);
-
-xd = max(0, rect->x);
-yd = max(0, rect->y);
-xf = min((img->width-1), (rect->x+rect->w));
-yf = min((img->height-1), (rect->y+rect->h));
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s:   %d %d %d %d\n", __func__, xd, yd, xf, yf);
-#endif
-
-for (x=xd; x<xf; x++)
-	{
-	for (y=yd; y<yf; y++)
-		{
-		(img->Rpix[y])[x] = rand() % r;
-		(img->Gpix[y])[x] = rand() % g;
-		(img->Bpix[y])[x] = rand() % b;
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* 
- * kikoo lol a tous les goret-codeurs, et en particulier Mr Spleyt.
- */
-

Lib/halfsize.c

@@ -1,105 +0,0 @@
-
-/*
-                    halfsize.c
-		------------------
-	
-	see also: scale.c doublesz.c
-
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-#include   <math.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	Fabrication d'une image moitié de l'image source.
- *
- *	cette fonction alloue une _nouvelle_ image
- *                                ==========
- *	méthodes:
- *		0: primitive.
- *		1: semblant d'interpolation.
- *
- */
-Image_Desc *
-Image_MakeHalfSize(Image_Desc *image, int methode)
-{
-int		largeur, hauteur, x, y, xx, yy;
-Image_Desc	*demi;
-
-largeur = image->width / 2;     hauteur = image->height / 2;
-
-if (image->type != IMAGE_RGB)
-	{
-	fprintf(stderr, "Image HalfSize: bad image type %d\n", image->type);
-	return NULL;
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "MakeHalfSize: from %dx%d, method %d  -> %d x %d\n",
-		image->width, image->height, methode, largeur, hauteur);
-#endif
-
-demi = Image_alloc(largeur, hauteur, image->type);
-if ( demi == NULL )
-	{
-	fprintf(stderr, "Image make half size: no memory\n");
-	exit(5);
-	}
-
-/*
- *	ne faudrait-il pas transmettre certains des attributs de
- *	l'image originale à la nouvelle image ?
- */
-demi->modified = 0;
-demi->errmsg = image->errmsg;
-
-for (y=0; y<hauteur; y++)
-    {
-    yy = y * 2;
-    for (x=0; x<largeur; x++)
-        {
-        xx = x * 2;
-        switch(methode)
-            {
-            case 0:
-                (demi->Rpix[y])[x] = (image->Rpix[yy])[xx];
-                (demi->Gpix[y])[x] = (image->Gpix[yy])[xx];
-                (demi->Bpix[y])[x] = (image->Bpix[yy])[xx];
-                break;
-
-	    case 1:
-                (demi->Rpix[y])[x] = (	 (image->Rpix[yy])[xx]   +
-					 (image->Rpix[yy+1])[xx] +
-					 (image->Rpix[yy])[xx+1] +
-					 (image->Rpix[yy+1])[xx+1] ) / 4;
-           
-                (demi->Gpix[y])[x] = (	 (image->Gpix[yy])[xx]   +
-					 (image->Gpix[yy+1])[xx] +
-					 (image->Gpix[yy])[xx+1] +
-					 (image->Gpix[yy+1])[xx+1] ) / 4;
-           
-                (demi->Bpix[y])[x] = (	 (image->Bpix[yy])[xx]   +
-					 (image->Bpix[yy+1])[xx] +
-					 (image->Bpix[yy])[xx+1] +
-					 (image->Bpix[yy+1])[xx+1] ) / 4;
-           
-		break;
-
-	    default:
-		/*
-		 * et ici, un message d'erreur ?
-		 */
-		break;
-            }
-        }
-    }
-
-demi->modified = 1;
-
-return demi;		/* demi is a pointer to an Image_Desc ! */
-}
-/*::------------------------------------------------------------------::*/

Lib/patterns.c

@@ -1,175 +0,0 @@
-/*
-                    patterns.c
-		------------------
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-#include   <math.h>
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_000(Image_Desc *img, int foo)
-{
-int	x, y, xx, yy, r, g, b;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : foo = %d\n", __func__, foo);
-#endif
-
-for (x=0; x<img->width; x++)
-	{
-	xx = (x * 256) / img->width;
-	for (y=0; y<img->height; y++)
-		{
-		yy = (y * 256) / img->height;
-		r = xx & yy & foo;
-		g = ((xx * yy) & 0xf8 );
-		b = xx ^ yy;
-		Image_plotRGB(img, x, y, r, g, b);
-		}
-	}
-/*
-   sometime, a newbie ask me: "why use intermediate vars: r, g, and b ?"
-   my answer was: "clarity of code, small scarabée".
-*/ 
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_001(Image_Desc *img, int foo)
-{
-int	x, y;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : foo is %d\n", __func__, foo);
-#endif
-
-for (x=0; x<img->width; x++)
-	for (y=0; y<img->height; y++)
-		Image_plotRGB(img, x, y, x^y^foo, (x*y)>>4, x&y);
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_002(Image_Desc *img, int foo)
-{
-int	x, y, x2, y2;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Pattern 002: %d\n", foo);
-#endif
-
-for (x=0; x<img->width; x++)
-    {
-    x2 = (x * 256) / img->width;
-    for (y=0; y<img->height; y++)
-	{
-	y2 = (y * 256) / img->height;
-	Image_plotRGB(img, x, y, (x2/2)&(y2/2)&foo, (x2*y2)>>3, x2^y2);
-	}
-    }
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_003(Image_Desc *img, int foo)
-{
-int	x, x2, y, y2;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Pattern 003: foo is %d\n", foo);
-#endif
-
-/* added some ugly code the 28 february 2008 */
-for (x=0; x<img->width; x++)
-    {
-    x2 = (x * 256) / img->width;
-    for (y=0; y<img->height; y++)
-	{
-	y2 = (y * 256) / img->height;
-	Image_plotRGB(img, x, y, (x2/4)&(y2/4)&foo, (x2*y2)>>5, x2^y2);
-	}
-    }
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_004(Image_Desc *img, int a, int b, int c, int d)
-{
-#if DEBUG_LEVEL
-fprintf(stderr, "Pattern 004: %d, %d, %d, %d\n", a, b, c, d);
-#endif
-
-fprintf(stderr, "NO CODE HERE\n");
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int Image_pattern_005(Image_Desc *img, RGB_map *map)
-{
-int		x, y;
-double		fx, fy;
-int		idx;
-
-if (NULL == map) {
-	fprintf(stderr, "in %s:%s, map is NULL\n",
-				__FILE__, __func__);
-	return NULL_POINTER;
-	}
-
-for (y=0; y<img->height; y++)
-	{
-	fy = (double)y;
-	for (x=0; x<img->width; x++)
-		{
-		fx = (double)x;
-		
-		idx = (int)(127.0+(sin(fx)*cos(fy)*254.99));
-		idx &= 0xff;
-
-		(img->Gpix[y])[x] = map->green[idx];
-		(img->Bpix[y])[x] = map->blue[idx];
-		}
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_042(Image_Desc *img, int foo)
-{
-int	x, y, r, g, b;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Pattern 042: threshold level is %d\n", foo);
-#endif
-
-r = g = b = 42;
-for (x=0; x<img->width; x++)
-	{
-	for (y=0; y<img->height; y++)
-		{
-		r += rand() % 4;
-		if (r > foo)	r = 0;
-
-		g += rand() % 4;
-		if (g > foo)	g = 0;
-
-		b += rand() % 4;
-		if (b > foo)	b = 0;
-
-		/* Image_plotRGB(img, x, y, r, g, b); */
-		(img->Rpix[y])[x] = r;
-		(img->Gpix[y])[x] = g;
-		(img->Bpix[y])[x] = b;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/

Lib/patterns2.c

@@ -1,121 +0,0 @@
-/*
-                    patterns2.c
-		------------------
-	various random patterns.
-
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-int
-Image_texture_0(Image_Desc *dst, int bas, int haut)
-{
-int	foo;
-
-fprintf(stderr, "Texture 0: obsolete! use 'Image_gray_noise_0' now!\n");
-
-foo = Image_gray_noise_0(dst, bas, haut);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_texture_1(Image_Desc *dst, int bas, int haut)
-{
-int	x, y, r, g, b;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Texture 1:  %d %d\n", bas, haut);
-#endif
-
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		r = rand()%(haut-bas) + bas;
-		g = rand()%(haut-bas) + bas;
-		b = rand()%(haut-bas) + bas;
-
-		(dst->Rpix[y])[y] = r;
-		(dst->Gpix[y])[y] = g;
-		(dst->Bpix[y])[y] = b;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	en cours de mise au point ? à quoi servent les paramètres ?
- *	ou est la doc ? mais que fait tTh ? il moule dans une tribune ?
- */
-int
-Image_texture_2(Image_Desc *dst, int bas, int haut, int mod)
-{
-int	x, y, r, g, b, foo;
-
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Image texture 2: this func is experimental ;)\n");
-#endif
-
-if (mod == 0)
-	{
-	fprintf(stderr, "Image texture 2: 'mod' must be positive.\n");
-	return DIVISOR_IS_ZERO;
-	}
-
-r = g = b = 127;
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		foo = rand() % mod;
-		switch(foo)
-			{
-			case  0: r = rand()%(haut-bas) + bas;	break;
-			case  1: g = rand()%(haut-bas) + bas;	break;
-			case  2: b = rand()%(haut-bas) + bas;	break;
-			case  3: r = b = g = haut;		break;
-			case  4: r = b = g = bas;		break;
-			case  5: r = 0;				break;
-			case  6: g = 0;				break;
-			case  7: b = 0;				break;
-		/*
-		 * à partir de là, il y a beaucoup de 'case'
-		 * qui se ressemblent trop...
-		 */
-			case  8: r = (x * rand()) & 0xff;	break;
-			case  9: g = (x * rand()) & 0xff;	break;
-			case 10: b = (x * rand()) & 0xff;	break;
-			case 11: r = (y * rand()) & 0xff;	break;
-			case 12: g = (y * rand()) & 0xff;	break;
-			case 13: b = (y * rand()) & 0xff;	break;
-			}
-		(dst->Rpix[y])[x] = r;
-		(dst->Gpix[y])[x] = g;
-		(dst->Bpix[y])[x] = b;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	bon sang, j'ai le prototype sous les yeux, mais je n'ai pas
- *	la moindre idée de ce que doit faire la fonction !
- */
-int
-Image_texture_3(Image_Desc *dst, int bas, int haut, char *ctl, int quux)
-{
-int	x, y;
-
-fprintf(stderr, "Texture 3 is not here\n");
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/

Lib/patterns3.c

@@ -1,142 +0,0 @@
-/*
-                    patterns3.c
-		------------------
-	see also 'patterns.c' & 'patterns2.c'
-
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-#include   <unistd.h>
-#include   <math.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- * c'est quasiment impossible de documenter cette fonction.
- */
-int
-Image_pattern_100(Image_Desc *dst, int kr, int kg, int kb)
-{
-int	x, y, r,g, b;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = abs(x+y-(dst->width/3)) * kr;
-		g = abs(x-y-(dst->height/3)) * kg;
-		b = (rand() % 42) + kb;
-
-		Image_plotRGB(dst, x, y, r, g, b);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_101(Image_Desc *dst, int kr, int kg, int kb)
-{
-int	x, y, r,g, b;
-
-if (kr == 0)		kr = 1;
-if (kg == 0)		kg = 1;
-if (kb == 0)		kb = 1;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		if (x < dst->width/2)
-			{ r=x/kr; g=y/kg; b=x/kb; }
-		else
-			{ r=y/kr; g=x/kg; b=y/kb; }
-		Image_plotRGB(dst, x, y, r, g, b);
-		}
-	}
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_pattern_102(Image_Desc *dst, int param, int kr, int kg, int kb)
-{
-int	x, y, r,g, b;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = x ^ kr;
-		g = y ^ kg;
-		b = (x+y) ^ kb;
-		Image_plotRGB(dst, x, y, r, g, b);
-		}
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/* hop, 31 mars 2008, une petite evolution stochastique de base...
- * */
-int
-Image_pattern_103(Image_Desc *dst, int param, int kr, int kg, int kb)
-{
-int		x, y, r, g, b;
-long		surface;
-double		dx, dy;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: acting on image %p\n", __func__, dst);
-#endif
-
-surface = dst->width * dst->height;
-
-for (x=0; x<dst->width; x++)
-	{
-	dx = (double)x / (double)dst->width;
-	for (y=0; y<dst->height; y++)
-		{
-		dy = (double)x / (double)dst->height;
-		r = (int)round(256.0 * sqrt(dx * dy));
-		g = b = rand() & 0xf0;
-		Image_plotRGB(dst, x, y, r, g, b);
-		}
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	new 10 juillet 2003
- */
-int
-Image_pattern_104(Image_Desc *dst, int sx, int sy, RGBA *a, RGBA *b)
-{
-int	x, y, fx, fy;
-
-for (x=0; x<dst->width; x++)
-	{
-	fx = x % sx;
-	for (y=0; y<dst->height; y++)
-		{
-		fy = y % sy;
-
-		if (fx==1 && fy==1)
-			{
-			Image_plotRGB(dst, x, y, a->r, a->g, a->b);
-			}
-		else
-			{
-			Image_plotRGB(dst, x, y, b->r, b->g, b->b);
-			}
-		}
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "%05d\r", x);
-#endif
-	}
-
-return FUNC_IS_ALPHA;
-}
-/*::------------------------------------------------------------------::*/

Lib/patterns4.c

@@ -1,233 +0,0 @@
-/*
-                    patterns4.c
-		    ------------------
-		    some random noises
-	
-	see also 'patterns.c' & 'patterns2.c'
-
-*/
-
-#include   <stdio.h>
-#include   <stdlib.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	bruit monochrome
- */
-int
-Image_gray_noise_0(Image_Desc *dst, int low, int high)
-{
-int	x, y, v, delta;
-
-delta = high - low;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		v = (rand() % delta) + low;
-		(dst->Rpix[y])[x] = v;
-		(dst->Gpix[y])[x] = v;
-		(dst->Bpix[y])[x] = v;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_rgb_noise_0(Image_Desc *dst, int low, int high)
-{
-int	x, y, r, g, b, delta;
-
-delta = high - low;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = (rand() % delta) + low;
-		g = (rand() % delta) + low;
-		b = (rand() % delta) + low;
-		(dst->Rpix[y])[x] = r;
-		(dst->Gpix[y])[x] = g;
-		(dst->Bpix[y])[x] = b;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_rgba_noise_0(Image_Desc *dst, int low, int high)
-{
-int	x, y, r, g, b, a, delta;
-
-if (dst->type != IMAGE_RGBA)
-	{
-	fprintf(stderr, "RGBA noise 0: image is not RGBA (%d)\n", dst->type);
-	return IMAGE_BAD_TYPE;
-	}
-
-if (dst->Apix == NULL)
-	{
-	fprintf(stderr, "RGBA noise 0: %p: no alpha buffer ?\n", dst);
-	return NO_ALPHA_CHANNEL;
-	}
-
-delta = high - low;
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = (rand() % delta) + low;
-		g = (rand() % delta) + low;
-		b = (rand() % delta) + low;
-		a = (rand() % delta) + low;
-		Image_plotRGBA(dst, x, y, r, g, b, a);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* new 21 mars 2002 - need more doc
- */
-int
-Image_rgb_noise_1(Image_Desc *dst, RGBA *low, RGBA *high)
-{
-int	minr, ming, minb;
-int	maxr, maxg, maxb;
-int	dltr, dltg, dltb;
-int	x, y, r, g, b;
-
-#if DEBUG_LEVEL
-Image_print_rgba("rgb noise 1: low", low, 0);
-Image_print_rgba("rgb noise 1: high", high, 0);
-#endif
-
-minr = (low->r < high->r) ? low->r : high->r;
-ming = (low->g < high->g) ? low->g : high->g;
-minb = (low->b < high->b) ? low->b : high->b;
-maxr = (low->r > high->r) ? low->r : high->r;
-maxg = (low->g > high->g) ? low->g : high->g;
-maxb = (low->b > high->b) ? low->b : high->b;
-dltr = maxr - minr;
-dltg = maxg - ming;
-dltb = maxb - minb;
-
-#if DEBUG_LEVEL
-printf("\n");
-printf("rgb noise 1: min    %3d  %3d  %3d\n", minr, ming, minb);
-printf("rgb noise 1: max    %3d  %3d  %3d\n", maxr, maxg, maxb);
-printf("rgb noise 1: delta  %3d  %3d  %3d\n", dltr, dltg, dltb);
-#endif
-
-if ( dltr==0 || dltg==0 || dltb==0 )
-	{
-	fprintf(stderr, "Rgb noise 1: a delta is zero...\n");
-	return DIVISOR_IS_ZERO;
-	}
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = (rand() % dltr) + minr;
-		g = (rand() % dltg) + ming;
-		b = (rand() % dltb) + minb;
-		(dst->Rpix[y])[x] = r;
-		(dst->Gpix[y])[x] = g;
-		(dst->Bpix[y])[x] = b;
-		}
-	}
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	pour avoir une courbe de répartition en cloche, j'utilise
- *	l'algo du "lancement de deux dés", mais ce n'est probablement
- *	pas très rigoureux :)
- */
-int
-Image_gray_noise_2(Image_Desc *dst, int low, int high)
-{
-int	x, y, v, delta;
-
-delta = (high - low) / 2;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Gray noise 2: low=%d high=%d delta=%d\n", low, high, delta);
-#endif
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		v = (rand()%delta) + (rand()%delta) + low;
-		(dst->Rpix[y])[x] = v;
-		(dst->Gpix[y])[x] = v;
-		(dst->Bpix[y])[x] = v;
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	hop, clonage du commentaire de la func du dessus :)
- *
- *	pour avoir une courbe de répartition en cloche, j'utilise
- *	l'algo du "lancement de deux dés", mais ce n'est probablement
- *	pas très rigoureux :)
- */
-int
-Image_rgb_noise_2(Image_Desc *dst, RGBA *low, RGBA *high)
-{
-int	x, y, r, g, b;
-int	minr, ming, minb;
-int	maxr, maxg, maxb;
-int	dltr, dltg, dltb;
-
-#if DEBUG_LEVEL
-Image_print_rgba("rgb noise 2: low", low, 0);
-Image_print_rgba("rgb noise 2: high", high, 0);
-#endif
-
-minr = (low->r < high->r) ? low->r : high->r;
-ming = (low->g < high->g) ? low->g : high->g;
-minb = (low->b < high->b) ? low->b : high->b;
-maxr = (low->r > high->r) ? low->r : high->r;
-maxg = (low->g > high->g) ? low->g : high->g;
-maxb = (low->b > high->b) ? low->b : high->b;
-dltr = maxr - minr;
-dltg = maxg - ming;
-dltb = maxb - minb;
-
-#if DEBUG_LEVEL
-printf("\n");
-printf("rgb noise 2: min    %3d  %3d  %3d\n", minr, ming, minb);
-printf("rgb noise 2: max    %3d  %3d  %3d\n", maxr, maxg, maxb);
-printf("rgb noise 2: delta  %3d  %3d  %3d\n", dltr, dltg, dltb);
-#endif
-
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		r = (rand()%dltr) + (rand()%dltr) + minr;
-		g = (rand()%dltg) + (rand()%dltg) + ming;
-		b = (rand()%dltb) + (rand()%dltb) + minb;
-		(dst->Rpix[y])[x] = r;
-		(dst->Gpix[y])[x] = g;
-		(dst->Bpix[y])[x] = b;
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/

Lib/pixeliz.c

@@ -1,84 +0,0 @@
-/*
- *		pixeliz.c
- *		---------
- *
- *	nouveau 23 Juin 2003, je ne sais pas quoi mettre dedans...
- *	14 mars 2007: je ne sais toujours pas...
- *
- */
-
-#include  <stdio.h>
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-int
-Image_pixeliz_0(Image_Desc *src, Image_Desc *dst, int w, int h)
-{
-int		x, y, foo, N;
-int		r, g, b;
-int		xmax, ymax;
-Image_Rect	zone;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Pixeliz 0: en chantier    w %d  h %d\n", w, h);
-#endif
-
-if ( (foo=Image_compare_desc(src, dst)) ) {
-    fprintf(stderr, "%s : images are differents %d\n", __func__, foo);
-    return foo;
-    }
-
-zone.w = w;
-zone.h = h;
-
-xmax = src->width - w;
-ymax = src->height - h;
-
-for (x=0; x<=xmax; x+=w) {
-	zone.x = x;
-	for (y=0; y<=ymax; y+=h) {
-		zone.y = y;
-/*		Image_dump_rect(&zone, "z", 0); */
-
-		foo = Image_stats_zone_0(src, &zone, &r, &g, &b, &N, &N, &N);
-		foo = Image_paint_rect(dst, &zone, r, g, b);
-		}
-	}
-
-dst->modified = 1;
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fonction d'appel de test
- */
-int
-Image_pixeliz_X(Image_Desc *src, Image_Desc *dst)
-{
-int foo;
-
-fprintf(stderr, "Pixeliz X: appel de test, pas finalise.\n");
-
-foo = Image_pixeliz_0(src, dst, 5, 13);
-fprintf(stderr, "Pixeliz X: valeur obtenue: %d\n", foo);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fonction d'appel de test
- */
-int
-Image_pixeliz_Y(Image_Desc *src, Image_Desc *dst)
-{
-int foo;
-
-fprintf(stderr, "Pixeliz Y: appel de test, pas finalise.\n");
-
-foo = Image_pixeliz_0(src, dst, 13, 5);
-fprintf(stderr, "Pixeliz Y: valeur obtenue: %d\n", foo);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/

Lib/pixels.c

@@ -1,38 +0,0 @@
-/*
- *		PIXELS dot C
- */
-
-#include  <stdio.h>
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-int
-Image_XOR_pixel(Image_Desc *img, int x, int y, int r, int g, int b)
-{
-int	pr, pg, pb, a;
-
-if ( (x<0) || (y<0) || (x>=img->width) || (y>=img->height) )
-	{
-	fprintf(stderr, "%s : out of pic (%d, %d)\n", __func__, x, y);
-	return OUT_OF_IMAGE;
-	}
-
-img->Rpix[y][x] ^= r;
-img->Gpix[y][x] ^= g;
-img->Bpix[y][x] ^= b;
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-int Image_rot_pixel(Image_Desc *img, int x, int y, int r, int g, int b)
-{
-
-if ( (x<0) || (y<0) || (x>=img->width) || (y>=img->height) )
-	{
-	fprintf(stderr, "%s : out of pic (%d, %d)\n", __func__, x, y);
-	return OUT_OF_IMAGE;
-	}
-
-return 42;
-}
-/*::------------------------------------------------------------------::*/

Lib/plotteur.c

@@ -1,552 +0,0 @@
-/*
-			plotteur.c
-			----------
-*/
-
-#include  <stdio.h>
-#include  <string.h>
-#include  <stdlib.h>
-
-#ifdef NEED_ALLOCA_H
-#include  <alloca.h>
-#endif
-
-#include  "../tthimage.h"
-
-#define	SOMBRE	26		/* pourquoi ces valeurs sont codées en	*/
-#define CLAIR	242		/* dur ? et ~/.tth/libimagerc alors ? 	*/
-
-/*::------------------------------------------------------------------::*/
-static void vline(Image_Desc *i, int x, int y1, int y2, char c, int v)       
-{
-int haut, bas, foo;
-
-if (y1 > y2)	{ bas = y2;   haut = y1; }
-else        	{ bas = y1;   haut = y2; }
-
-for (foo=bas; foo<=haut; foo++)
-	Image_plot_channel(i, c, x, foo, v);
-}
-/*::------------------------------------------------------------------::*/
-/* new 20 mars 2002
-									*/
-int
-Image_plot_luts(char *nomtga, int *lr, int *lg, int *lb, char *texte)
-{
-Image_Desc	*img;
-int		foo;
-RGBA		paper, ink;
-int		vr, vg, vb, ovr, ovg, ovb;
-
-if ( (img = Image_alloc(400, 300, 3)) == NULL )
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "Plot Luts: alloc of img failed, file=%s\n", nomtga);
-#endif
-	return IMAGE_NO_MEM;
-	}
-
-Image_clear(img, SOMBRE, SOMBRE, SOMBRE);
-
-ovr = ovg = ovb = 0;			/* warning suppressor */
-for (foo=0; foo<256; foo++)
-	{
-	vr = lr[foo];
-	vg = lg[foo];
-	vb = lb[foo];
-	if (foo)
-		{
-		vline(img, foo+60, 290-vr, 290-ovr, 'r', CLAIR);
-		vline(img, foo+60, 290-vg, 290-ovg, 'g', CLAIR);
-		vline(img, foo+60, 290-vb, 290-ovb, 'b', CLAIR);
-		}
-
-	ovr = vr;   ovg = vg;   ovb = vb;
-	}
-
-if (texte != NULL)
-	{
-	paper.r = paper.b = paper.g = SOMBRE;	paper.a = 0;
-	ink.r = ink.b = ink.g = CLAIR;		ink.a = 255;
-	Image_trace_chaine_1(img, texte, 5, 5, "libimage.fonte", &paper, &ink);
-	}
-
-Image_cadre_A(img);
-foo=Image_TGA_save(nomtga, img, 0);
-Image_DeAllocate(img);		free(img);
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/*
- * fevrier 2009 : je constate avec amertume que cette fonction ne
- *                remplit plus vraiment son role face aux exigences
- *                de buzzwording du monde moderne. un revamping me
- *                semble vraiment necessaire.
- */
-int
-Image_plot_histo(char *nomtga, long *hr, long *hg, long *hb, char *txt)
-{
-Image_Desc	*img;
-int		foo, vr, vg, vb, ovr, ovg, ovb;
-long		maxhisto;
-RGBA		paper, ink;
-char		chaine[120];
-
-if ( (img = Image_alloc(400, 300, 3)) == NULL )
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "Plot Histo: alloc of img failed, file=%s\n", nomtga);
-#endif
-	return IMAGE_NO_MEM;
-	}
-
-maxhisto = 0;
-for (foo=0; foo<256; foo++)
-	{
-	if (hr[foo] > maxhisto)	maxhisto = hr[foo];
-	if (hg[foo] > maxhisto)	maxhisto = hg[foo];
-	if (hb[foo] > maxhisto)	maxhisto = hb[foo];
-	}
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "plot histo: max rgb = %ld\n", maxhisto);
-#endif
-
-Image_clear(img, SOMBRE, SOMBRE, SOMBRE);	/* ou est SOMBRE ? */
-
-ovr = ovg = ovb = 0;			/* warning suppressor */
-for (foo=0; foo<256; foo++)
-	{
-	vr = (hr[foo]*256)/maxhisto;
-	vg = (hg[foo]*256)/maxhisto;
-	vb = (hb[foo]*256)/maxhisto;
-	if (foo)
-		{
-		vline(img, foo+60, 290-vr, 290-ovr, 'r', CLAIR);
-		vline(img, foo+60, 290-vg, 290-ovg, 'g', CLAIR);
-		vline(img, foo+60, 290-vb, 290-ovb, 'b', CLAIR);
-		}
-	ovr = vr;   ovg = vg;   ovb = vb;
-	}
-
-paper.r = paper.b = paper.g = SOMBRE;	paper.a = 0;
-ink.r = ink.b = ink.g = CLAIR;		ink.a = 255;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "taille txt %d\n", strlen(txt));
-#endif
-
-Image_trace_chaine_1(img, txt, 5, 5, "libimage.fonte", &paper, &ink);
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "[%s] tracée...\n", txt);
-#endif
-
-sprintf(chaine, "max rgb = %ld", maxhisto);
-Image_trace_chaine_1(img, chaine, 5, 15, NULL, &paper, &ink);
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "[%s] tracée...\n", chaine);
-#endif
-
-Image_cadre_A(img);
-foo=Image_TGA_save(nomtga, img, 0);
-Image_DeAllocate(img);		free(img);
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/* mmmmm, pas tres sexy, ce truc-la...
- */
-int
-Image_calc_plot_histo(Image_Desc *img, char *tganame)
-{
-long	hr[256], hg[256], hb[256];
-int	foo;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : %p --> '%s'\n", __func__, img, tganame);
-#endif
-
-foo = Image_histo_RGB(img, hr, hg, hb);
-Image_print_error("calc plot histo: calc", foo);
-foo = Image_plot_histo(tganame, hr, hg, hb, tganame);
-Image_print_error("calc plot histo: plot", foo);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fabrique dans une image une petite bande a partir d'une palette
- *	cette bande est horizontale.
- */
-int
-Image_plot_h_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int h)
-{
-int	x, y, v;
-
-for (x=0; x<256; x++)
-	{
-	for (y=0; y<h; y++)
-		{
-		if ( ((y>>2)+(x>>2)) & 1)	v = SOMBRE;
-		else				v = CLAIR;
-		Image_plotRGB(img, x+xpos, y+ypos, v, v, v);
-		}
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Image plot h Map: %d colors\n", map->nbre);
-#endif
-
-for (x=0; x<map->nbre; x++)
-	{
-	for (y=0; y<h; y++)
-		{
-		Image_plotRGB(img, x+xpos, y+ypos,
-				map->red[x], map->green[x], map->blue[x]); 	
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fabrique dans une image une petite bande a partir d'une palette
- *	cette bande est verticale.
- */
-int
-Image_plot_v_Map(Image_Desc *img, RGB_map *map, int xpos, int ypos, int l)
-{
-int	x, y, v;
-
-for (y=0; y<256; y++)
-	{
-	for (x=0; x<l; x++)
-		{
-		if ( ((y>>2)+(x>>2)) & 1)	v = SOMBRE;
-		else				v = CLAIR;
-		Image_plotRGB(img, x+xpos, y+ypos, v, v, v);
-		}
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Image plot v Map: %d colors\n", map->nbre);
-#endif
-
-for (y=0; y<map->nbre; y++)
-	{
-	for (x=0; x<l; x++)
-		{
-		Image_plotRGB(img, x+xpos, y+ypos,
-				map->red[y], map->green[y], map->blue[y]); 	
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fabrique une petite TGA horizontale avec une palette dedans
- */
-#define LITTLE_DIM 42
-int
-Image_plot_little_h_Map(char *nom, RGB_map *map, char *texte)
-{
-Image_Desc *img;
-int	foo;
-
-if ( (img=Image_alloc(260, LITTLE_DIM+4, 3)) == NULL)
-	{
-	return IMAGE_NO_MEM;
-	}
-foo = Image_plot_h_Map(img, map, 2, 2, LITTLE_DIM);
-#if DEBUG_LEVEL
-fprintf(stderr, "Plot little H map: ret plot = %d, %s\n",
-						foo, Image_err2str(foo));
-#endif
-
-(void)Image_cadre_A(img);
-
-if (texte != NULL)	Image_set_comment(img, texte);
-
-foo = Image_TGA_save(nom, img, 0);
-fprintf(stderr, "plot little H map: save %s: %d\n", nom, foo);
-
-Image_DeAllocate(img);	free(img);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	20 Février 2002.
- *	fabrique une petite TGA verticale avec une palette dedans
- */
-int
-Image_plot_little_v_Map(char *nom, RGB_map *map, char *texte)
-{
-Image_Desc	*img;
-int		foo;
-
-if ( (img=Image_alloc(LITTLE_DIM+4, 260, 3)) == NULL)
-	{
-	return IMAGE_NO_MEM;
-	}
-
-foo = Image_plot_v_Map(img, map, 2, 2, LITTLE_DIM);
-
-(void)Image_cadre_A(img);
-
-if (texte != NULL)	Image_set_comment(img, texte);
-
-foo = Image_TGA_save(nom, img, 0);
-fprintf(stderr, "plot little V map: save '%s': %d\n", nom, foo);
-
-Image_DeAllocate(img);	free(img);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* new 2 decembre 2009 - ave St Exupery 
- */
-int
-Image_plot_square_Map(char *fname, RGB_map *map, char *texte, int k)
-{
-int		x, y, foo;
-int		r, g, b;
-Image_Desc	*img;
-Image_Rect	rect;
-
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( '%s' %p '%s' %d )\n", __func__,
-			fname, map, texte, k);
-#endif
-
-if ( (img = Image_alloc(512, 512, 3)) == NULL )
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "Plot MAP: alloc of img failed, file=%s\n", fname);
-#endif
-	return IMAGE_NO_MEM;
-	}
-
-Image_clear(img, 0, 0, 0);
-
-rect.h = rect.w = 31;
-
-for (foo=0; foo<256; foo++)
-	{
-	x = ( foo & 0x0f ) * 32;
-	y = ( foo & 0xf0 ) * 2;
-#if DEBUG_LEVEL > 1
-	printf("%4d : %3d %3d ", foo, x, y);
-#endif
-	
-	rect.x = x;
-	rect.y = y;
-
-	if (foo < map->nbre)
-		{
-		r = map->red[foo];
-		g = map->green[foo];
-		b = map->blue[foo];
-#if DEBUG_LEVEL > 1
-		printf("  %3d %3d %3d\n", r, g, b);
-#endif
-		Image_paint_rect(img, &rect, r, g, b);
-		}
-	else		/* on est au dela de la fin de la palette */
-		{
-#if DEBUG_LEVEL > 1
-		printf("  xxx\n");
-#endif
-		/* Image_gadrct_Hsweep_0(img, &rect, 0); */
-		Image_gadrct_cross(img, &rect, 0);
-		}
-	}
-
-
-
-foo=Image_TGA_save(fname, img, 0);
-
-Image_DeAllocate(img);	free(img);
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	plotte une palette 'a la fractint'
- */
-int
-Image_plot_Map(char *nomtga, RGB_map *map , char *txt)
-{
-Image_Desc	*img;
-int		foo, x;
-RGBA		paper, ink;
-Image_Rect	rect;
-
-if ( (img = Image_alloc(400, 300, 3)) == NULL )
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "Plot MAP: alloc of img failed, file=%s\n", nomtga);
-#endif
-	return IMAGE_NO_MEM;
-	}
-
-Image_clear(img, SOMBRE, SOMBRE, SOMBRE);
-
-
-
-for (foo=0; foo<map->nbre; foo++)
-	{
-	Image_plotRGB(img, foo+90, 120, 255, 255, 255);
-	Image_plotRGB(img, foo+90, 200, 255, 255, 255);
-	Image_plotRGB(img, foo+90, 280, 255, 255, 255);
-
-	Image_plotRGB(img, foo+90, 120-(map->red[foo]/5),   255,   0,   0);
-	Image_plotRGB(img, foo+90, 200-(map->green[foo]/5),   0, 255,   0);
-	Image_plotRGB(img, foo+90, 280-(map->blue[foo]/5),    0,   0, 255);
-	}
-
-rect.x = 20;	rect.y = 30;
-rect.h = 258;	rect.w = 31;
-Image_draw_rect(img, &rect, CLAIR/2, CLAIR/2, CLAIR/2);
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "Plot MAP: the text is '%s'\n", txt);
-#endif
-
-for (foo=0; foo<map->nbre; foo++)
-	{
-	for (x=21; x<50; x++)
-		{
-		Image_plotRGB(img, x, foo+31,
-			map->red[foo], map->green[foo], map->blue[foo]);
-		}
-	}
-
-paper.r = paper.b = paper.g = SOMBRE;	paper.a = 0;
-ink.r = ink.b = ink.g = CLAIR;		ink.a = 255;
-foo = Image_trace_chaine_1(img, txt, 15, 7, "8x8thin", &paper, &ink);
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "Plot MAP: retour trace chaine = %d\n", foo);
-#endif
-Image_cadre_A(img);
-
-if ( (foo=Image_TGA_save(nomtga, img, 0)) )
-	{
-	Image_DeAllocate(img);		free(img);
-	return foo;
-	} 
-
-Image_DeAllocate(img);		free(img);
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	new 23 oct 2001
- *	parameters 'p1' and 'p2' are not used, and must be 0 !
- */
-int
-Image_plot_histo_hf15(Image_Desc *img, char *nom, char *txt, int p1, int p2)
-{
-Image_Desc	 *plot;
-long		*histo, maximum;
-double		diviseur;
-int		x, y, foo, h, h2, epic_fail;
-RGBA		paper, ink;
-char		chaine[200];
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: img %p  ! work in progress !\n", __func__, img);
-#endif
-
-if ( (histo=alloca(sizeof(long)*32768)) == NULL)
-	{
-	fprintf(stderr, "Plot histo hf15: no mem for buffer\n");
-#if FORCE_ABORT
-	abort();
-#endif
-	return BUFFER_NO_MEM;
-	}
-
-if ( (plot = Image_alloc(800, 600, 3)) == NULL )
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "Plot histo hf15: alloc img failed\n");
-#endif
-	return IMAGE_NO_MEM;
-	}
-
-Image_clear(plot, SOMBRE, SOMBRE, SOMBRE);
-for (foo=0; foo<32768; foo++)	histo[foo] = 0L;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "Plot histo hf15: buffers allocated, computing now...\n");
-#endif
-
-epic_fail = 0;
-for (y=0; y<img->height; y++)
-	{
-	for (x=0; x<img->width; x++)
-		{
-		h = Image_hf15_height(img, x, y);
-		if (h<0 || h>32767)
-			epic_fail++;
-		else
-			histo[h]++;
-		}
-	}
-
-if (epic_fail)
-	{
-	fprintf(stderr, "%s : %d epic fail is epic\n", __func__, epic_fail);
-#if FORCE_ABORT
-	abort();
-#endif
-	}
-
-/* recherche du maximum de l'histogramme, pour faire la mise a l'echelle */
-maximum = 0L;
-for (foo=0; foo<32768; foo++)
-	if (histo[foo] > maximum)
-		maximum = histo[foo];
-
-diviseur = (double)maximum/400.0;
-if (diviseur==0)	diviseur=1.0;		/* XXX workaround */
-
-fprintf(stderr, "%s: maximum = %ld, diviseur = %g\n", __func__,
-				maximum,	diviseur);
-
-h2 = 0;
-for (foo=0; foo<32768; foo+=4)
-	{
-	h = (int)((double)histo[foo] / diviseur);
-	x = (foo/64)+60;
-	if (foo)	/* pourquoi ? */
-		{
-		vline(plot, x, 590-h, 290-h2, 'g', CLAIR);
-		h2 = h;
-		}
-	Image_plotRGB(plot, x, 590-h, CLAIR, SOMBRE, SOMBRE);
-	Image_plotRGB(plot, x, 590, SOMBRE, CLAIR, SOMBRE);
-	}
-
-paper.r = paper.b = paper.g = SOMBRE;	paper.a = 0;
-ink.r = ink.b = ink.g = CLAIR;		ink.a = 255;
-/* Image_trace_chaine_0(plot, txt, 5, 5, &paper, &ink, 0); */
-Image_trace_chaine_1(plot, chaine, 5, 5, NULL, &paper, &ink);
-sprintf(chaine, "max %ld", maximum);
-/* Image_trace_chaine_0(plot, chaine, 5, 15, &paper, &ink, 0); */
-Image_trace_chaine_1(plot, chaine, 5, 15, NULL, &paper, &ink);
-sprintf(chaine, "div %g", diviseur);
-/* Image_trace_chaine_0(plot, chaine, 5, 25, &paper, &ink, 0); */
-Image_trace_chaine_1(plot, chaine, 5, 25, NULL, &paper, &ink);
-
-Image_cadre_A(plot);
-foo=Image_TGA_save(nom, plot, 0);
-
-Image_DeAllocate(plot);		free(plot);
-
-return FUNC_IS_BETA;	
-}
-/*::------------------------------------------------------------------::*/

Lib/pov_hf15a.c

@@ -1,438 +0,0 @@
-/*
-                pov_hf15.c
-                ==========
-
-	Un 'height_field' de POVray est une image au format TGA
-	qui stocke des altitudes sur 15 bits, avec les poids
-	forts dans la composante rouge et les poids faibles dans
-	la composante verte. Pour le bleu, je ne sais pas ce
-	qu'il en est, donc on va le forcer a 0.
-
-2 oct 2001: adding a function for writing a PGM 15 bits file.
-16 oct 2001: the 'read pgm hf' func of Povray seems bogus, so we have
-	to wait for POV 3.5 for testing my func :(
-23 oct 2001: all references to 16 bits are supersedes by reference
-	to 15 bits. after all, it's better ?
-
-	-------------------------------------------------
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*
- *	que faire si l'altitude est negative ? on clampe !-)
- *	... et rappelons qu'il faut sauver en TGA pour que Pov
- *	retrouve ses 2^15 valeurs d'altitude.
- */
-int Image_hf15_plot(Image_Desc *im, int x, int y, int h)
-{
-int	r, g;
-
-if (h < 0)	h = 0;		/* On clampe ... */
-if (h > 32767)	h = 32767;
-
-if ((x<0) || (y<0) || (x>=im->width) || (y>im->height))
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "%s : %d,%d out of image\n", __func__, x, y);
-#endif
-	return OUT_OF_IMAGE;
-	}
-
-r = (h >> 8) & 0xff;		/* les poids forts */
-g = h & 0xff;			/* les poids faibles */
-
-(im->Rpix[y])[x] = r;
-(im->Gpix[y])[x] = g;
-(im->Bpix[y])[x] = 0;	/* valeur 'secure', on pourrait y mettre */
-			/* autre chose. voir les sources de pov ? */
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	recuperer la hauteur stockée dans une image 'hf15'
- *	en cas de dépassement, la valeur est silencieusement limitée.
- */
-int Image_hf15_height(Image_Desc *img, int x, int y)
-{
-register int a, b;
-int	h;
-
-if ((x<0) || (y<0) || (x>=img->width) || (y>img->height))
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "%s : %d,%d out of image\n", __func__, x, y);
-#endif
-	/* VERY BAD BUG HERE */
-	return OUT_OF_IMAGE;
-	}
-
-/* 28 mars 2007 : optimization for speed -> use direct access 
-h = (Image_R_pixel(img, x, y) << 8) + Image_G_pixel(img, x, y);
-*/
-a = (img->Rpix[y])[x];
-b = (img->Gpix[y])[x];
-h = ( a << 8) + b;
-
-return h & 0x7fff;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	parameter 'mode' is not used. set it to 0, please.
- */
-int Image_hf15_hf2gray(Image_Desc *src, Image_Desc *dst, int mode)
-{
-int	x, y, h;
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y) >> 7;
-		Image_plotRGB(dst, x, y, h, h, h);
-		}
-	}
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* il y a peut-etre une maniere plus astucieuse de choisr ces
- * coeeficients que de prendre des valeurs arbitraires... */
-#define K_R	65
-#define K_G	42		/* il faut bien le caser, le 42 */
-#define K_B	19
-#define K_TOT	(K_R+K_G+K_B)
-
-/* parameter 'mode' is not used at this time. please use 0 ! */
-int Image_hf15_rgb2hf(Image_Desc *src, Image_Desc *dst, int mode)
-{
-int	x, y, h, hmax, hmin;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "RGB -> HF: k_tot = %d\n", K_TOT);
-fprintf(stderr, "           max_v = %d\n", K_R*255+K_G*255+K_B*255);
-#endif
-
-if (0 != mode)
-	{
-	fprintf(stderr, "when calling %s, mode must be 0\n", __func__);
-#if FORCE_ABORT
-	abort();
-#endif
-	}
-
-hmax = -9999;	hmin = 424242;
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h =  Image_R_pixel(src, x, y) * K_R +
-		     Image_G_pixel(src, x, y) * K_G +
-		     Image_B_pixel(src, x, y) * K_B ;
-		
-#if DEBUG_LEVEL
-		if (h > hmax)	hmax = h;
-		if (h < hmin)	hmin = h;
-#endif
-
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "           h min = %d, h max = %d\n", hmin, hmax);
-#endif
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	Warning: this 15 bit (valid?) pgm file can't be loaded
- *	by POVray. I've send a bug report, but get no answer
- *	from the POV team.... 
- *	May be we have to wait for the release of v3.5 ?
- */
-#define VERSION_STRING  "PGM hf15 / Janv 2010"
-#define TAILLE_BUFFER 65536
-int Image_hf15_save_PGM(char *nom, Image_Desc *img, char *comment)
-{
-FILE	*fp;
-int	x, y, h, foo;
-int	par_ligne, nbr_overshoot;
-
-char	buffer[TAILLE_BUFFER];
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: saving %p as file '%s'\n", __func__, img, nom);
-#endif
-
-if ((fp=fopen(nom, "w")) == NULL)
-	{
-	fprintf(stderr, "ecriture PGM hf15 %s err fopen\n", nom);
-	return FILE_CREATE_ERR;
-	}
-foo = setvbuf(fp, buffer, _IOFBF, TAILLE_BUFFER);
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: setvbuf -> %d\n", __func__, foo);
-#endif
-
-fprintf(fp, "P2\n%d %d\n32767\n", img->width, img->height);
-fprintf(fp, "#\n# written by libimage v %s, %s\n",
-			IMAGE_VERSION_STRING, VERSION_STRING);	
-if (comment != NULL)
-	fprintf(fp, "# %s\n", comment);
-fputs("#\n", fp);
-
-nbr_overshoot = 0;
-par_ligne = 0;
-for (y=0; y<img->height; y++)
-	{
-	for (x=0; x<img->width; x++)
-		{
-		h = Image_R_pixel(img, x, y) * 256 +
-		    Image_G_pixel(img, x, y);
-
-		if (h > 32767)
-			{
-			fprintf(stderr, "overshoot at %d,%d -> %d\n",
-							x, y, h);
-
-			if (nbr_overshoot > 42)
-				{
-#if FORCE_ABORT
-				abort();
-#endif
-				}
-			nbr_overshoot++;
-			h = 32767;
-			}
-		foo = fprintf(fp, "%d ", h);
-		par_ligne += foo;
-		if (par_ligne > 65)		/* magic value ? */
-			{
-			fputs("\n", fp);
-			par_ligne = 0;
-			}
-		}
-#if DEBUG_LEVEL > 1
-	fprintf(fp, "\n# end of src pixline %d\n", y);
-#endif
-	}
-
-fputs("\n", fp);
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "Pov hf15 save PGM: %p %s: a re-tester...\n", img, nom);
-#endif
-fclose(fp);
-
-if (nbr_overshoot)
-	fprintf(stderr, "in %s, on a eu %d overshoots\n",
-			__func__, nbr_overshoot);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-static struct 
-	{
-	int	x, y;
-	} deltas[] = 
-{	{ -1,	-1, },
-	{  0,	-1, },
-	{  1,	-1, },
-	{ -1,	 0, },
-	{  0,	 0, },
-	{  1,	 0, },
-	{ -1,	 1, },
-	{  0,	 1, },
-	{  1,	 1  }
-};	
-
-#define PRECISION 42			/* à quoi ça sert ? */
-
-int
-Image_hf15_lissage(Image_Desc *s, Image_Desc *d, int coef, int flag)
-{
-int	x, y, h, cumul, foo;
-int	r, g;
-long	temps, nbpix=0L;
-#if DEBUG_LEVEL
-double	ttp;
-int	under, over;
-#endif
-
-if (flag)
-	{
-	fprintf(stderr, "Warning! Lissage hf15: flag (%d) must be 0\n", flag);
-#if FORCE_ABORT
-	abort();
-#endif
-	}
-	
-#if DEBUG_LEVEL 
-fprintf(stderr, ">>> Lissage hf15 : %p -> %p : coef %d, flag 0x%04x\n",
-				s, d, coef, flag);
-#endif
-
-#if DEBUG_LEVEL > 1
-Image_start_chrono("lissage hf15", 15);
-#endif
-
-/* BIG FIX at night, the 7 january 2010 */
-/* we _must_ clean the border of the target image buffer */
-Image_raz_sides(d);
-
-#if DEBUG_LEVEL
-under = over = 0;
-#endif
-
-for (y=1; y<s->height-1; y++)
-    {
-    for (x=1; x<s->width-1; x++)
-        {
-        cumul = 0;
-        for (foo=0; foo<9; foo++)
-            {
-	    /* XXX attention optimisation dangeureuse. 
-            h = Image_R_pixel(s, x+deltas[foo].x, y+deltas[foo].y) * 256 +
-                Image_G_pixel(s, x+deltas[foo].x, y+deltas[foo].y);
-	    XXX car on utilise un acces 'insecure' a la memoire image */
-	    h  = (s->Rpix[y+deltas[foo].y])[x+deltas[foo].x] * 256;
-	    h += (s->Gpix[y+deltas[foo].y])[x+deltas[foo].x]; 
-	    h &= 0x7fff;
-	    h *= PRECISION;
-
-	    if (foo==4)		cumul += (h*coef);
-	    else		cumul += h;
-            }
-
-	cumul /= ((8+coef)*PRECISION);
-
-	if (cumul > 32767)
-		{
-		cumul = 32767;
-#if DEBUG_LEVEL
-		over++;
-#endif
-		}
-	if (cumul < 0)
-		{
-		cumul = 0;
-#if DEBUG_LEVEL
-		under++;
-#endif
-		}
-
-        r = (cumul >> 8) & 0x7f;
-        g = cumul & 0xff;	
-
-	(d->Rpix[y])[x] = r;
-	(d->Gpix[y])[x] = g;
-	(d->Bpix[y])[x] = 0;
-
-	nbpix++;
-        }
-    }
-
-#if DEBUG_LEVEL
-if (under || over)
-	fprintf(stderr, "%s : under=%d over=%d\n", __func__, under, over);
-#endif
-
-#if DEBUG_LEVEL > 1
-temps = Image_stop_chrono(NULL, 15);
-ttp = ((double)temps / (double)nbpix)*1000000.0;
-fprintf(stderr, "Lissage hf15: %.4f µs/pixel\n", ttp); 
-#endif
-
-d->modified = 1;
-
-return FUNC_IS_BETA;	
-}
-/*::------------------------------------------------------------------::*/
-/*
- *		WARNING! experimental: prototype may change!
- */
-int
-Image_hf15_calc_minmax(Image_Desc *img, char *txt, int *pmin, int *pmax)
-{
-int	x, y, h, minH, maxH;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p, '%s', %p, %p )\n", __func__, img, txt, pmin, pmax);
-#endif
-
-minH = 99999999;		maxH = -99999999;
-
-for (y=1; y<img->height-1; y++)
-    {
-    for (x=1; x<img->width-1; x++)
-        {
-        h = (Image_R_pixel(img, x, y) << 8) +
-            Image_G_pixel(img, x, y);
-	if (h > maxH)	maxH = h;
-	if (h < minH)	minH = h;
-	}
-    }
-
-if (txt != NULL)
-	{
-	fprintf(stderr, "* hf15 @ %p * %s :  min=%d  max=%d\n",
-						img, txt, minH, maxH);
-	}
-
-if (pmin != NULL)	*pmin = minH;
-if (pmax != NULL)	*pmax = maxH;
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* new 6 Nov 2001 */
-/*
- *                       Need more doc !
- */
-int
-Image_hf15_mul_add(Image_Desc *src, Image_Desc *dst, int mul, int add)
-{
-int	x, y, h;
-
-fprintf(stderr, "Pov hf15: mul %d & add %d\n", mul, add);
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y);
-		h = (h * mul) + add;
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* new 6 Nov 2001 */
-int
-Image_hf15_invert(Image_Desc *src, Image_Desc *dst)
-{
-int	x, y, h;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : %p --> %p\n", __func__, src, dst);
-#endif
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = 32768 - Image_hf15_height(src, x, y);
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/

Lib/pov_hf15b.c

@@ -1,134 +0,0 @@
-/*
-                pov_hf15b.c
-                ===========
-
-    for information about this file:
-			ask Thierry Boudet 
-
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*
- *  new 24 oct 2001 - not really crah-proff
- */
-int
-Image_hf15_normalize(Image_Desc *src, Image_Desc *dst, int low, int high)
-{
-int	x, y, minH, maxH, foo;
-int	delta, ecart;
-double	mult, dh;
-
-foo = Image_hf15_calc_minmax(src, NULL, &minH, &maxH);
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: src %p is %d < H < %d\n", __func__, src, minH, maxH);
-#endif
-
-delta = maxH - minH;
-ecart = high - low;
-if ((0==delta) || (0==ecart))
-	{
-	fprintf(stderr, "Pov hf15 normalize: ZERO DIVIDE!\n");
-	return DIVISOR_IS_ZERO;
-	}
-
-mult = (double)ecart / (double)delta;
-#if DEBUG_LEVEL
-fprintf(stderr, "Pov hf15 normalize: delta %d, mult %f\n", delta, mult);
-#endif
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		dh = (double)Image_hf15_height(src, x, y);
-		dh = (dh * mult) + (double)low;
-		Image_hf15_plot(dst, x, y, (int)dh);
-		}
-	}
-
-#if DEBUG_LEVEL
-foo = Image_hf15_calc_minmax(dst, NULL, &minH, &maxH);
-fprintf(stderr, "Pov hf15 normalize: we got %d < H < %d\n", minH, maxH);
-#endif
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/* New: 10 Nov 2001
- *
- */
-int
-Image_hf15_make_colmap_0(Image_Desc *src, Image_Desc *dst, char *mapname)
-{
-int	foo, x, y, h;
-RGB_map	map;
-
-if ( (foo=Image_compare_desc(src, dst)) )
-	{
-	fprintf(stderr, "Hf15 make colmap 0: differents dimensions %d\n",
-									foo);
-	return foo;
-	}
-
-foo=Image_load_color_Map(mapname, NULL, &map);
-if ( foo && foo!=MAP_TOO_BIG )
-	{
-	fprintf(stderr, "Hf15 make colmap 0: err load colormap '%s': %d / %s\n",
-					mapname, foo, Image_err2str(foo));
-	return foo;
-	}
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y) / 128;
-#if FORCE_ABORT
-		if (h<0 || h>255)	abort();
-#endif
-		Image_plotRGB(dst, x, y, map.red[h], map.green[h], map.blue[h]);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* New: 18 Dec 2001
- *
- */
-int
-Image_hf15_make_colmap_1(Image_Desc *src, Image_Desc *dst, RGB_map *map)
-{
-int	foo, x, y, h;
-
-if ( (foo=Image_compare_desc(src, dst)) )
-	{
-	fprintf(stderr, "Hf15 make colmap 1: differents dims %d\n", foo);
-	return foo;
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : data@ is %p\n", __func__, map);
-#endif
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y) / 128;
-#if FORCE_ABORT
-		if (h<0 || h>255)	abort();
-#endif
-		Image_plotRGB(dst, x, y,
-			map->red[h], map->green[h], map->blue[h]);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/

Lib/pov_hf15c.c

@@ -1,263 +0,0 @@
-/*
-                pov_hf15c.c
-                ===========
-
-	Mixing operations beetween two height-fields.
-	---------------------------------------------
-*/
-
-#include  <stdio.h>
-#include  <string.h>
-#include  <math.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*
- *  new 10 Décembre 2001
- *
- *     Le coefficient K va de 0 a 10000 !
- */
-int
-Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int k)
-{
-int	foo, x, y, h1, h2, hd;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: k = %d\n", __func__, k);
-#endif
-
-if ( (foo=Image_compare_desc(s1, s2)) )
-	{
-	fprintf(stderr, "hf15 mix: err on sources: %s\n", Image_err2str(foo));
-	return foo;
-	}
-if ( (foo=Image_compare_desc(s1, dst)) )
-	{
-	fprintf(stderr, "hf15 mix: err on dest: %s\n", Image_err2str(foo));
-	return foo;
-	}
-
-for (y=0; y<s1->height; y++)
-	{
-	for (x=0; x<s1->width; x++)
-		{
-		h1 = Image_hf15_height(s1, x, y);
-		h2 = Image_hf15_height(s2, x, y);
-		hd = ((h1*k) + (h2*(10000-k))) / 10000;
-		Image_hf15_plot(dst, x, y, hd);
-		}
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Image hf15 mix: done.\n");
-#endif
-
-dst->modified = 1;
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *  new 5 Janvier 2003
- *	il y a probablement des problemes d'overflow ici.
- */
-int
-Image_hf15_mult_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
-{
-int	foo, x, y, h1, h2, hd;
-
-if ( (foo=Image_compare_desc(s1, s2)) )
-	{
-	fprintf(stderr, "hf15 mult i: err on srces: %s\n", Image_err2str(foo));
-	return foo;
-	}
-if ( (foo=Image_compare_desc(s1, dst)) )
-	{
-	fprintf(stderr, "hf15 mult: err on dest: %s\n", Image_err2str(foo));
-	return foo;
-	}
-
-for (y=0; y<s1->height; y++)
-	{
-	for (x=0; x<s1->width; x++)
-		{
-		h1 = Image_hf15_height(s1, x, y);
-		h2 = Image_hf15_height(s2, x, y);
-		hd = (h1 * h2) / 32768;
-		Image_hf15_plot(dst, x, y, hd);
-		}
-	}
-
-dst->modified = 1;
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* nouveau 17 novembre 2009 - avenue St Exupery */
-int 
-Image_hf15_mult_k(Image_Desc *s, Image_Desc *d, float dk)
-{
-int	foo, x, y, h1, h2;
-
-if ( (foo=Image_compare_desc(s, d)) )
-	{
-	fprintf(stderr, "hf15 mult k: error: %s\n", Image_err2str(foo));
-	return foo;
-	}
-
-for (y=0; y<s->height; y++)
-	{
-	for (x=0; x<s->width; x++)
-		{
-		h1 = Image_hf15_height(s, x, y);
-		h2 = (int)( (float)h1 * dk );
-		Image_hf15_plot(d, x, y, h2);
-		}
-	}
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/* nouveau Juin 2008 - avenue St Exupery */
-int
-Image_hf15_div_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
-{
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %p %p )\n", __func__, s1, s2, dst);
-#endif
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/* nouveau Juin 2008 - avenue St Exupery */
-int
-Image_hf15_sqrt(Image_Desc *src, Image_Desc *dst)
-{
-int		x, y, h;
-int		foo;
-float		rh, mean_a;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
-#endif
-
-if ( (foo=Image_compare_desc(src, dst)) )
-	{
-	fprintf(stderr, "hf15 sqrt: (failed) : %s\n", Image_err2str(foo));
-	return foo;
-	}
-
-mean_a = 0.0;
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y);
-		if (h < 0)
-			{
-			fprintf(stderr, "WTF ! %s  %p  %d,%d   %d\n",
-						__func__,
-						src, x, y, h);
-#if FORCE_ABORT
-			fflush(stdout);
-			abort();
-#endif
-			}
-		rh = (float)h / 32767.0;
-		mean_a += rh;				/* c'est quoi ? */
-		h  = (int)(sqrt(rh) * 32767.0);
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* nouveau Novembre 2008 - avenue St Exupery */
-int
-Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double p0w44)
-{
-int		x, y, h;
-int		foo;
-/* hu ho 27 jan 2010 :  pourquoi on ne calcule pas en double precision ? */
-float		rh;
-float		minh, maxh;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p, %g )\n", __func__, src, dst, p0w44);
-#endif
-
-if ( (foo=Image_compare_desc(src, dst)) )
-	{
-	fprintf(stderr, "%s : (fail) : %s\n", __func__, Image_err2str(foo));
-	return foo;
-	}
-minh =  999999.99;
-maxh = -999999.99;
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y);
-		rh = (float)h / 32768.0;
-		rh = pow(rh, p0w44);
-		if (rh < minh)		minh = rh;
-		if (rh > maxh)		maxh = rh;
-		h  = (int)(rh * 32767.0);
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-fprintf(stderr, "%s -> %f %f\n", __func__, minh, maxh);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int Image_hf15_exp1(Image_Desc *src, Image_Desc *dst)
-{
-int		foo, x, y, h;
-/*
- * on va calculer en double precision, parce que je suis un dino et
- * que ma machine de dev ne connait pas 'expf' 
- */
-double		rh;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
-#endif
-
-if ( (foo=Image_compare_desc(src, dst)) )
-	{
-	fprintf(stderr, "%s : (fail) : %s\n", __func__, Image_err2str(foo));
-	return foo;
-	}
-
-for (y=0; y<src->height; y++)
-	{
-	for (x=0; x<src->width; x++)
-		{
-		h = Image_hf15_height(src, x, y);
-		rh = (double)h / 32768.0;
-		rh = exp(rh) - 1.0;
-
-		h  = (int)(rh * 32767.0);
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-
-return FUNC_IS_ALPHA;
-}
-
-int Image_hf15_exp2(Image_Desc *src, Image_Desc *dst)
-{
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
-#endif
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-

Lib/pov_hf15d.c

@@ -1,215 +0,0 @@
-/*
-                pov_hf15d.c
-                ===========
-	bruitages de height-fields.
-	---------------------------
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*
- *	le hasard choisi quel pixel on va changer.
- *	le hasard choisi quelle valeur on va lui affecter, et cette
- *	 valeur sera comprise entre 'hi' et 'lo'.
- */
-int
-Image_hf15_noise_0(Image_Desc *dst, int hi, int lo, int prob100)
-{
-int	delta;
-int	x, y, h;
-
-#if DEBUG_LEVEL
-fprintf(stderr, ">>>> %s ( %p %d %d %d )\n", __func__,
-				dst, hi, lo, prob100);
-#endif
-
-delta = hi - lo;
-if (0 == delta)
-	{
-	fprintf(stderr, "%s : delta is zero, fail.\n", __func__);
-	return DIVISOR_IS_ZERO;
-	}
-
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		if ((rand()%100) < prob100)
-			{ 
-			/*
-			 * en fait je ne suis pas content de cette fonction
-			 * de bruit, et je cherche une meilleur solution.
-			 */
-			h = (rand()%delta) + lo;
-			Image_hf15_plot(dst, x, y, h);
-			}
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- * new 21 avr 2009: the probability use is (mis)used.
- */
-int
-Image_hf15_noise_1(Image_Desc *dst, int mo, int of, int prob100)
-{
-int	x, y, h, vr;
-#if DEBUG_LEVEL
-long	hit, mess;
-float	ratio;
-#endif
-
-#if DEBUG_LEVEL 
-fprintf(stderr, "Hf15 noise 1 is very experimental.\n");
-hit = mess = 0L;
-#endif
-
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		if (prob100 > rand()%100)
-			{
-#if DEBUG_LEVEL
-			hit++;
-#endif
-			h = Image_hf15_height(dst, x, y);
-			vr = (rand()%mo) + of;
-			h += vr;
-			Image_hf15_plot(dst, x, y, h);
-			}
-#if DEBUG_LEVEL
-		else
-			{
-			mess++;
-			}
-#endif
-		}
-	}
-
-#if DEBUG_LEVEL
-if (mess > 0)	ratio = (float)hit / (float)mess;
-else		ratio = -42.42;
-fprintf(stderr, "%s: hit %ld mess %ld\n", __func__, hit, mess);
-#endif
-
-return FUNC_IS_BETA;
-	/*
-	 * penser à faire des tests de cette fonction :)
-	 */
-}
-/*::------------------------------------------------------------------::*/
-/*
- * remplacement aléatoire d'un point par un de ses proches voisins
- */
-int
-Image_hf15_noise_2(Image_Desc *dst, int pr100, int dist, int k1, int k2)
-{
-Image_Desc	*clone;
-int		x, y, h;
-int		xs, ys;
-int		hit, mess;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Hf15 noise 2 is _very_ experimental\n");
-#endif
-
-/*
- * faire une copie de l'image, qui servira de source.
- */
-clone = Image_clone(dst, 1);
-
-hit = mess = 0;
-
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		if ( pr100 > (rand()%100) )
-			{
-			xs = x + (rand() % dist);
-			ys = y + (rand() % dist);
-			if (Image_xy_inside(clone, xs, ys))
-				{
-				h = Image_hf15_height(clone, xs, ys);
-				Image_hf15_plot(dst, x, y, h);
-				hit++;
-				}
-			}
-		else
-			{
-			mess++;
-			}
-		}
-	}
-/*
- * détruire la copie de l'image.
- */
-Image_DeAllocate(clone);	free(clone);
-
-/* afficher les stats a la con */
-fprintf(stderr, "%s : hit=%d mess=%d\n", __func__, hit, mess);
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*
- * deplacement aleatoire d'un point proportionnellement a sa hauteur.
- * new 2 juillet 2009 - pour la colline de Sonia dans le Parking Maudit. 
- */
-int
-Image_hf15_noise_3(Image_Desc *dst, double coef, int flag)
-{
-int		x, y, h;
-double		dh, dh2, dr, maxdh;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %f 0x%X )\n", __func__, dst, coef, flag);
-#endif
-
-if (0 != flag)
-	{
-	fprintf(stderr, "%s : flag is 0x%d and _must_ be 0\n",
-							__func__, flag);
-	}
-
-maxdh = 0;
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		dh = (double)Image_hf15_height(dst, x, y);
-		dr = ((double)rand() / (double)RAND_MAX) - 0.50000000;
-
-		dh2 = dh + (dr * coef * (dh / 32768.0));
-		if (dh2 > maxdh)
-			{
-			maxdh = dh2;
-#if DEBUG_LEVEL > 1
-			printf("dh is %f, dr is %f, max is %f\n",
-						dh, dr, maxdh);
-#endif
-			}
-
-		/* is the clipping mandatory ? */
-		h = (int)dh2;
-		if (h < 0)		h = 0;
-		if (h > 32767)		h = 32767;
-
-		Image_hf15_plot(dst, x, y, h);
-		}
-	}
-
-#if DEBUG_LEVEL
-printf("%s : maxdh = %f\n", __func__, maxdh);
-#endif
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/

Lib/pov_hf15e.c

@@ -1,101 +0,0 @@
-/*
-                pov_hf15e.c
-                ===========
-
-	opérations de morphologie mathématique appliquées
-	aux height-fields.
-
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-static struct 
-	{
-	int	x, y;
-	} off[] = 
-	{
-	{ -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
- *	pas trop quoi y mettre ?
- */
-int
-Image_hf15_dilate(Image_Desc *src, Image_Desc *dst, int coef)
-{
-int	foo;
-int	x, y, h, hmax;
-
-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 (x=1; x<dst->width-1; x++)
-		{
-		hmax = -1664;
-		for (foo=0; foo<9; foo++)
-			{
-			h = Image_hf15_height(src, x+off[foo].x, y+off[foo].y);
-			if (h > hmax) hmax = h;
-			}
-		Image_hf15_plot(dst, x, y, hmax);	
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	le paramètre 'coef' n'est pas utilisé.
- */
-int
-Image_hf15_erode(Image_Desc *src, Image_Desc *dst, int coef)
-{
-int	foo;
-int	x, y, h, hmin;
-
-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 (x=1; x<dst->width-1; x++)
-		{
-		hmin = 42042;
-		for (foo=0; foo<9; foo++)
-			{
-			h = Image_hf15_height(src, x+off[foo].x, y+off[foo].y);
-			if (h < hmin) hmin = h;
-			}
-		Image_hf15_plot(dst, x, y, hmin);	
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *		Et maintenant, il reste à coder le chapeau haut-de-forme
- */
-/*::------------------------------------------------------------------::*/
-

Lib/pov_hf15f.c

@@ -1,134 +0,0 @@
-/*
-                pov_hf15f.c
-                ===========
-	traitement des bords des height-fields.
-	---------------------------------------
-	new 3 octobre 2009 - avenue StExupery
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*	Abaissement graduel des bords d'un height field 		*/
-/*	Inspiration : 'Image_cadre_C'					*/
-/* TODO : build a real unit test */
-/* TODO : expliquer les parametres */
-
-int Image_hf15_sweep(Image_Desc *im, int hfin, int taille, int k)
-{
-int		x, y, x2, y2;
-float		fhfin, fx, fy, coef, d;
-int		hit, mess, h, h2;
-
-#if DEBUG_LEVEL 
-fprintf(stderr, "%s : img=%p   hfin=%d   taille=%d   k=%d\n",
-				__func__, im, hfin, taille, k);
-fprintf(stderr, "   pic dims : %d x %d\n", im->width, im->height);
-#endif
-
-/* this is really a MESS ! */
-fhfin = (float)(hfin*hfin);
-x2 = im->width / 2;
-y2 = im->height / 2;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "   fhfin=%f      x2=%d  y2=%d\n", fhfin, x2, y2);
-#endif
-
-hit = mess = 0;
-
-for (y=0; y<im->height; y++)
-	{
-	/*
-	 *	distance au bord HAUT BAS le plus proche
-	 */
-	if (y < y2)	fy = (float)y;
-	else		fy = (float)((im->height - y)-1);
-	fy = fy*fy;
-
-	for (x=0; x<im->width; x++)
-		{
-		/*
-		 *	distance au bord DROITE GAUCHE le plus proche
-		 */
-		if (x < x2)	fx = (float)x;
-		else		fx = (float)((im->width - x)-1);
-		fx = fx*fx;
-
-		/* XXX  un peu plus d'explications ici */
-		if (fx < fy)	d = fx;
-		else		d = fy;
-
-		if (d < fhfin)
-			{
-			coef = d / fhfin;
-			h = Image_hf15_height(im, x, y);
-			h2 = (int)(((float)h*coef) + ((float)hfin*(1.0-coef)));
-#if DEBUG_LEVEL > 1
-			printf("__sweep__ %5d %d\n", h, h2);
-#endif
-			if ( h<0 || h>32767)
-				{
-				fprintf(stderr, "%s fail %d %d\n",
-							__func__, x, y);
-				abort();
-				}
-			Image_hf15_plot(im, x, y, h2);
-			hit ++;
-			}
-		else
-			{
-			mess ++;
-			}
-		}
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "      hit %d     mess %d\n", hit, mess);
-#endif
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-int Image_hf15_getmin(Image_Desc *s1, Image_Desc *s2, Image_Desc *d)
-{
-int	x, y, h1, h2;
-
-for (y=0; y<d->height; y++)
-	{
-	for (x=0; x<d->width; x++)
-		{
-		h1 = Image_hf15_height(s1, x, y);
-		h2 = Image_hf15_height(s2, x, y);
-		if (h1 < h2)
-			Image_hf15_plot(d, x, y, h1);
-		else
-			Image_hf15_plot(d, x, y, h2);
-		}
-	}
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-int Image_hf15_getmax(Image_Desc *s1, Image_Desc *s2, Image_Desc *d)
-{
-int	x, y, h1, h2;
-
-for (y=0; y<d->height; y++)
-	{
-	for (x=0; x<d->width; x++)
-		{
-		h1 = Image_hf15_height(s1, x, y);
-		h2 = Image_hf15_height(s2, x, y);
-		if (h1 > h2)
-			Image_hf15_plot(d, x, y, h1);
-		else
-			Image_hf15_plot(d, x, y, h2);
-		}
-	}
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-

Lib/pov_synth.c

@@ -1,193 +0,0 @@
-/*
-                pov_hf_synth.c
-                ==============
-		Thierry Boudet  
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <math.h>
-
-#include  "../tthimage.h"        
-
-/*::------------------------------------------------------------------::*/
-/*   new 6 Jan 2002, pas fini le 6 Jan 2003.  */
-int
-Image_hf15_synth_0(Image_Desc *dst, Image_PtList *ptl)
-{
-int	foo, nb, idx;
-int	x, y, dist, distmin;
-int	ptx, pty, xx, yy;
-
-fprintf(stderr, "%s:%d (%s) img %p ptl %p\n", __FILE__, __LINE__, __func__,
-					dst, ptl);
-
-if (ptl->control != 0xfde9601a)
-	{
-	fprintf(stderr, "%p is not a ptlist\n", ptl);
-	return -1;
-	}
-
-nb = ptl->nbre;
-printf("%s : il y a %d points dans la liste %p\n", __func__, nb, ptl);
-
-for (y=0; y<dst->height; y++)
-	{
-	for (x=0; x<dst->width; x++)
-		{
-		idx = -9999;	
-		distmin = 99999999;
-		for (foo=0; foo<nb; foo++)
-			{
-			ptx = ptl->points[foo].x;
-			pty = ptl->points[foo].y;
-			xx = x - ptx;
-			yy = y - pty;
-			dist = (xx*xx) + (yy*yy);
-			if (dist < distmin)
-				{
-				distmin = dist;
-				idx = foo;
-				}
-			}
-		/* got a value */
-		Image_hf15_plot(dst, x, y, ptl->points[idx].h);
-		}
-	}
-
-return FULL_NUCKED;
-}
-/*
- *	pourtant, il me semble qu'il existe un code Fortran qui 
- *	commence à bien fonctionner ?
- */
-/*::------------------------------------------------------------------::*/
-/*
- * remise en chantier de ce truc le 31 janvier 2008 -
- */
-static int plot_synth_1(Image_Desc *img, int x, int y, double dh)
-{
-int	ih;
-
-ih = (int)(dh);
-#if DEBUG_LEVEL > 1
-printf("   (%d,%d) -> %g  ->  %d\n", x, y, dh, ih);
-#endif
-Image_hf15_plot(img, x, y, ih);
-
-#define COEF 0.777
-ih = (int)(dh*COEF);
-Image_hf15_plot(img, x-1, y  , ih);
-Image_hf15_plot(img, x+1, y  , ih);
-Image_hf15_plot(img, x  , y-1, ih);
-Image_hf15_plot(img, x  , y+1, ih);
-
-ih = (int)(dh*COEF);
-Image_hf15_plot(img, x-1, y-1, ih);
-Image_hf15_plot(img, x-1, y+1, ih);
-Image_hf15_plot(img, x+1, y-1, ih);
-Image_hf15_plot(img, x+1, y+1, ih);
-
-ih = (int)(dh*COEF);
-Image_hf15_plot(img, x-2, y  , ih);
-Image_hf15_plot(img, x+2, y  , ih);
-Image_hf15_plot(img, x  , y-2, ih);
-Image_hf15_plot(img, x  , y+2, ih);
-
-return 1;
-}
-/*	++++++++++++++++++++++++++++++++++++	*/
-int
-Image_hf15_synth_1(Image_Desc *dst, Image_PtList *ptl)
-{
-int		idx, nb;
-double		dbl_h;
-
-printf("**** %s:%s: %p %p\n", __FILE__, __func__, dst, ptl);
-
-if (ptl->control != 0xfde9601a)
-	{
-	fprintf(stderr, "%s: %p is not a ptlist\n", __func__, ptl);
-	return -1;
-	}
-
-nb = ptl->nbre;
-printf("%s : il y a %d points dans la liste %p\n", __func__, nb, ptl);
-
-for (idx=0; idx<nb; idx++)
-	{
-#if DEBUG_LEVEL > 1
-	printf("point #%d\n", idx);
-#endif
-	dbl_h = (double)ptl->points[idx].h;
-	plot_synth_1(dst, ptl->points[idx].x, ptl->points[idx].y, dbl_h);
-	}
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/* new 11 decembre 2007 - ave St Exupery */
-int
-Image_hf15_synth_fromfunc0(Image_Desc *dst, int param,
-				double(*func)(int x, int y, int k))
-{
-int		x, y;
-double		dx, dy, val;
-double		minh, maxh, delta;
-long		surface;
-double		*array, *ptr;
-double		a, b;
-
-printf("%s: %p  %d\n", __func__, dst, param);
-surface = (long)dst->height * (long)dst->width;
-printf("   surface image: %ld pixels\n", surface);
-array = malloc(sizeof(double)*surface);
-if  (NULL == array)
-	{
-	fprintf(stderr, "no mem at %s:%s:%d\n", __FILE__, __func__, __LINE__);
-	abort();
-	}
-minh =  9e99;
-maxh = -9e99;
-ptr  = array;
-for (x=0; x<dst->width; x++)
-	{
-	dx = (double)x;
-	for (y=0; y<dst->height; y++)
-		{
-		dy = (double)y;
-		val = func(x, y, 51);
-		*ptr++ = val;
-		if (val < minh)		minh = val;
-		if (val > maxh)		maxh = val;
-		}
-	}
-delta = maxh - minh;
-printf("extremums:     %.12g     %.12g\n", minh, maxh);
-printf("delta:         %.12g\n", delta);
-
-a = 32766.9999 / delta;
-b = - ( a * minh );
-printf("  a  &  b:     %.12g     %.12g\n", a, b);
-
-minh =  9e99;
-maxh = -9e99;
-ptr  = array;
-for (x=0; x<dst->width; x++)
-	{
-	for (y=0; y<dst->height; y++)
-		{
-		val = *ptr++;
-		val = (a * val) + b;
-		if (val < minh)		minh = val;
-		if (val > maxh)		maxh = val;
-		Image_hf15_plot(dst, x, y, ceil(val));
-		}
-	}
-printf("altitudes:     %.12g     %.12g\n", minh, maxh);
-
-free(array);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/

Lib/scale.c

@@ -1,227 +0,0 @@
-
-/*
-                    scale.c
-		--------------
-
-	I think that I have to make an effort in math studies
-	for future enhancement of this module :)
-
-	see also: halfsize.c doublesz.c
-
-*/
-
-#include   <stdio.h>
-#include   <math.h>
-#include   <stdlib.h>
-
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	do not use in production !-)
- */
-int
-Image_scale_simple(Image_Desc *src, Image_Desc *dst, int k)
-{
-float	coefX, coefY, fx, fy;
-int	xd, yd, xs, ys;
-int	r, g, b;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "scale simple: %p (%dx%d) -> %p (%dx%d) k:%d \n",
-				src, src->width, src->height, 
-				dst, dst->width, dst->height, k);
-#endif
-
-coefX = (float)dst->width / (float)src->width;
-coefY = (float)dst->height / (float)src->height;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "coefficients:  X %f  y %f\n", coefX, coefY);
-#endif
-
-/*
- *	bon, pour les interpolations, il faut que je trouve
- *	un peu de doc... mais ou ?
- */
-for (yd=0; yd<dst->height; yd++)
-	{
-	for (xd=0; xd<dst->width; xd++)
-		{
-		fx = (float)xd / coefX;
-		fy = (float)yd / coefY;
-		xs = (int)fx;
-		ys = (int)fy;
-
-		Image_getRGB(src, xs, ys, &r, &g, &b);
-
-		(dst->Rpix[yd])[xd] = r;
-		(dst->Gpix[yd])[xd] = g;
-		(dst->Bpix[yd])[xd] = b;
-		}
-	}
-
-return FUNC_IS_ALPHA;
-}
-/*::------------------------------------------------------------------::*/
-/* new 2 nov 2009 - ave StEx */
-/* I've lost all my mathematical concepts (la vieillesse est un naufrage)
- * so I'm going to make some approximations\dots */
-
-static int getpix_bilin(Image_Desc *src, double fx, double fy, 
-					int *pr, int *pg, int *pb)
-{
-double	x11, y11, x22, y22;
-int	xx, yy;
-int	r11, g11, b11, r12, g12, b12,
-	r21, g21, b21, r22, g22, b22;
-double	drh, drw;
-double	raa, gaa, baa;
-double	rbb, gbb, bbb;
-double	rcc, gcc, bcc;
-
-/* before real ops, set RGB to some know values */
-*pr =  *pg = *pb = 0;
-
-/* build all the nasty values */
-x11 = floor(fx);	y11 = floor(fy);
-x22 = ceil(fx);		y22 = ceil(fy);
-drw = fx - x11;		drh = fy - y11;
-xx = (int)x11;		yy = (int)y11;
-
-#if DEBUG_LEVEL > 2
-if ( ! (rand() % 40000) )
-	printf("X %10.3f %10.3f %10.3f %10.3f    %4d\n",
-					fx, x11, x22, drw, xx);
-if ( ! (rand() % 40000) )
-	printf("Y %10.3f %10.3f %10.3f %10.3f    %4d\n",
-					fy, y11, y22, drh, yy);
-#endif
-
-if ( ! Image_xy_inside(src, xx, yy) )
-	return -1;
-if ( ! Image_xy_inside(src, xx+1, yy+1) )
-	return -2;
-
-
-r11 = src->Rpix[yy][xx]; g11 = src->Gpix[yy][xx]; b11 = src->Bpix[yy][xx];
-r12 = src->Rpix[yy][xx+1]; g12 = src->Gpix[yy][xx+1]; b12 = src->Bpix[yy][xx+1];
-r22 = src->Rpix[yy+1][xx+1]; g22 = src->Gpix[yy+1][xx+1]; b22 = src->Bpix[yy+1][xx+1];
-r21 = src->Rpix[yy+1][xx]; g21 = src->Gpix[yy+1][xx]; b21 = src->Bpix[yy+1][xx];
-
-/* hum hum... */
-raa = (double)r11 * (1.0-drw)  + (double)r12 * drw;
-gaa = (double)g11 * (1.0-drw)  + (double)g12 * drw;
-baa = (double)b11 * (1.0-drw)  + (double)b12 * drw;
-if (raa < 0.0)  abort(); 
-if (gaa < 0.0)  abort(); 
-if (baa < 0.0)  abort(); 
-
-rbb = (double)r21 * (1.0-drw)  + (double)r22 * drw;
-gbb = (double)g21 * (1.0-drw)  + (double)g22 * drw;
-bbb = (double)b21 * (1.0-drw)  + (double)b22 * drw;
-if (rbb < 0.0)  abort(); 
-if (gbb < 0.0)  abort(); 
-if (bbb < 0.0)  abort(); 
-
-rcc = (raa * (1.0-drh)) + (rbb * drh);
-gcc = (gaa * (1.0-drh)) + (gbb * drh);
-bcc = (baa * (1.0-drh)) + (bbb * drh);
-
-*pr = (int)rcc;   *pg = (int)gcc;   *pb = (int)bcc;
-
-return -105;
-}
-/*::------------------------------------------------------------------::*/
-int Image_scale_bilinear(Image_Desc *src, Image_Desc *dst, int k)
-{
-int	xd, yd, xs, ys, r, g, b;
-double	coefX, coefY;
-double	fxd, fyd, fxs, fys;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "scale bilinear: %p (%dx%d) -> %p (%dx%d) k:%d \n",
-				src, src->width, src->height, 
-				dst, dst->width, dst->height, k);
-#endif
-
-coefX = (double)dst->width / (double)src->width;
-coefY = (double)dst->height / (double)src->height;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : coefs  %lf %lf\n", __func__, coefX, coefY);
-#endif
-
-for (yd=0; yd<dst->height; yd++)
-	{
-	fyd = (double)yd;
-	fys = fyd / coefY;
-	for (xd=0; xd<dst->width; xd++)
-		{
-		fxd = (double)xd;
-		fxs = fxd / coefX;
-
-		getpix_bilin(src, fxs, fys, &r, &g, &b);
-
-		(dst->Rpix[yd])[xd] = r;
-		(dst->Gpix[yd])[xd] = g;
-		(dst->Bpix[yd])[xd] = b;
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int Image_getpix_bilin(Image_Desc *src, double fx, double fy, 
-					int *pr, int *pg, int *pb)
-{
-int	foo;
-
-foo = getpix_bilin(src, fx, fy, pr, pg, pb);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	for now, method must be 0 !
- */
-Image_Desc * Image_new_scale(	Image_Desc *src,
-				float scaleX, float scaleY,
-				int methode )
-{
-float	fx, fy;
-int	nw, nh, foo;
-
-Image_Desc	*dst;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "image\t%d %d, scale %f %f\n",
-		src->width, src->height, scaleX, scaleY);
-#endif
-
-fx = (float)src->width * scaleX;
-fy = (float)src->height * scaleY;
-
-nw = (int)(ceil((double)fx));
-nh = (int)(ceil((double)fy));
-
-#if DEBUG_LEVEL
-fprintf(stderr, "\t%f  %f\n", fx, fy);
-fprintf(stderr, "\tnew dims: %d x %d\n", nw, nh);
-#endif
-
-if ( (dst = Image_alloc(nw, nh, 3)) == NULL )
-	{
-	fprintf(stderr, "Image new/scale: no memory\n");
-	return NULL;
-	}
-
-#if DEBUG_LEVEL
-fprintf(stderr, "\tnew image @ %p\n", dst);
-#endif
-
-foo = Image_scale_simple(src, dst, 0);
-
-return dst;
-}
-/*::------------------------------------------------------------------::*/

Lib/t_t16x24.c

@@ -1,50 +0,0 @@
-/*
-     Proggy de test pour les fontes 16x24 - new 4 mai 2007, a StEx.
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-int essai_f1(char *tgasrc, char *tgadst, char *texte)
-{
-Image_Desc	*img;
-int		foo;
-RGBA		encre, papier;
-
-img = Image_TGA_alloc_load(tgasrc);
-
-foo = Image_t16x24_txtload("16x24thin", NULL, 0);
-
-encre.r = 0;	encre.g = 255;	encre.b = 100;	encre.a = 255;
-papier.r = 255;	papier.b = 0;	papier.g = 0;	papier.a = 200;
-
-foo = Image_t16x24_pltstr_1(img, texte, 2, 42, &papier, &encre, 0);
-
-foo = Image_TGA_save(tgadst, img, 0);
-
-return -1;
-}
-/*::------------------------------------------------------------------::*/
-int main(int argc, char *argv[])
-{
-char	*fichier;
-int	foo;
-Image_Desc	*image;
-
-fprintf(stderr, "-------------- %s ------------\n", argv[0]);
-foo = Image_t16x24_chars_map("16x24thin", "all16x24chars.tga", 0);
-foo = Image_t16x24_chars_map("bigfont.txt", "all16X24chars.tga", 0);
-fprintf(stderr, "--------------------------\n");
-Image_print_error("Essai fonte 16x24", foo);
-
-foo = essai_f1("pov.tga", "/tmp/aaaa_plop.tga", "0123456789");
-if (foo) {
-	fprintf(stderr, "   --->  %d\n", foo);
-	}
-return 0;
-}
-/*::------------------------------------------------------------------::*/

Lib/text0.c

@@ -1,290 +0,0 @@
-/*
-		text0.c
-		-------
-
-	ce module est en phase de 'reflexion'. je n'ai pas la moindre
-	idee sur l'organisation de la chose. je pense utiliser les
-	fontes bitmap de la console PC.
-
-	28 Fev 2001:	now the standard font is loaded from the file
-			/usr/local/share/libimage.fonte
-			
-*/
-
-#include  <stdio.h>
-#include  <unistd.h>
-#include  <stdlib.h>
-#include  <ctype.h>
-#include  <sys/types.h>
-#include  <sys/stat.h>
-#include  <fcntl.h>
-#include  <string.h>
-
-#include  "../tthimage.h"
-
-#define T_FONTE	2048
-
-static uint8_t	priv_fonte[T_FONTE];
-
-/*::------------------------------------------------------------------::*/
-/*
- * for now, parameter *ou must be NULL
- */
-int
-Image_load_fnt8x8(char *nomfnt, uint8_t *ou, int flags)
-{
-int	fd, foo;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s:  %s  %p  %d\n", __func__, nomfnt, ou, flags);
-#endif
-
-if (NULL != ou)
-	fprintf(stderr, "in %s, 'ou' (%p) must be NULL\n", __func__, ou);
-if (0 != flags)
-	fprintf(stderr, "in %s, 'flags' (%d) must be 0\n", __func__, flags);
-
-/* patch du 24 septembre 2015 */
-if (NULL == nomfnt) {
-	nomfnt = "libimage.fonte";
-	fprintf(stderr, "%s : using default font '%s'\n", __func__, nomfnt);
-	}
-/* on pourrait aussi mettre la fonte par ddefaut dans l'environ */
-
-if ( (fd=Image_must_open(nomfnt, O_RDONLY, 0)) < 0 )
-	{
-	perror (nomfnt);
-	exit(5);
-	}
-
-foo = read(fd, priv_fonte, T_FONTE);
-if ( foo != T_FONTE )
-	{
-	fprintf(stderr, "%s: error when reading font datas\n", __func__);
-	exit(5);
-	}
-close(fd);
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s : font '%s' loaded\n", __func__, nomfnt);
-#endif
-
-return OLL_KORRECT;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	XXX nasty bug in the alpha channel gestion XXX
- */
-int
-Image_trace_caractere_2(Image_Desc *im, uint8_t *fnt, int x, int y, int code,
-				RGBA *paper, RGBA *ink)
-{
-int	foo, bar, xi, yi;
-int	rp, gp, bp, rs, gs, bs;
-uint8_t	octet;
-
-#if DEBUG_LEVEL > 2
-fprintf(stderr, "trace car 2: xy= %4d %4d  c= %c\n", x, y,
-		isprint(code) ? code : ' ');
-#endif
-
-if (NULL==fnt)
-	{
-	fnt = priv_fonte;		/* use local static storage */
-	}
-
-for (foo=0; foo<8; foo++)
-	{
-	yi = y+foo;
-	octet = fnt[(code*8)+foo];
-	for (bar=0; bar<8; bar++)
-		{
-		xi = x+7-bar;
-		
-		/* lecture contenu image */
-		rs = (im->Rpix[yi])[xi];
-		gs = (im->Gpix[yi])[xi];
-		bs = (im->Bpix[yi])[xi];
-
-		if (octet & 1)			/* ENCRE */
-			{
-			rp = ((rs*(255-ink->a))+(ink->r*ink->a)) / 255;
-			gp = ((gs*(255-ink->a))+(ink->g*ink->a)) / 255;
-			bp = ((bs*(255-ink->a))+(ink->b*ink->a)) / 255;
-			}
-		else				/* PAPIER */
-			{
-			rp = ((rs*(255-paper->a))+(paper->r*paper->a)) / 255;
-			gp = ((gs*(255-paper->a))+(paper->g*paper->a)) / 255;
-			bp = ((bs*(255-paper->a))+(paper->b*paper->a)) / 255;
-			}
-		(im->Rpix[yi])[xi] = rp;
-		(im->Gpix[yi])[xi] = gp;
-		(im->Bpix[yi])[xi] = bp;
-
-		octet >>= 1;
-		}
-	}
-return 42;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	fonction très primitive...
- */
-int
-Image_trace_caractere(Image_Desc *im, int x, int y, int code)
-{
-int	foo, bar;
-uint8_t	octet;
-
-for (foo=0; foo<8; foo++)
-	{
-	octet = priv_fonte[(code*8)+foo];
-	for (bar=0; bar<8; bar++)
-		{
-		if (octet & 1)
-			Image_plotRGB(im, x+8-bar, y+foo, 255, 255, 255);
-		else
-			Image_plotRGB(im, x+8-bar, y+foo, 0, 0, 5);
-		octet >>= 1;
-		}
-	}
-
-return 42;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	trace d'une chaine. (param 'flag' not used)
- *	OBSOLETE FUNCTION !
- */
-int Image_trace_chaine_0(Image_Desc *im, char *txt, int x, int y,
-				RGBA *paper, RGBA *ink, int flags)
-{
-int	foo;
-
-fprintf(stderr, "THE FUNCTION '%s' IS OBSOLETE\n", __func__);
-if (0 != flags)
-	fprintf(stderr, "in %s, 'flags' (%d) must be 0\n", __func__, flags);
-foo = Image_trace_chaine_1(im, txt, x, y, "libimage.fonte", paper, ink);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	trace d'une chaine avec choix eventuel de la fonte par le 
- *	nom du fichier. Si celui-ci est NULL, c'est la fonte actuelle
- *	qui est utilise.
- */
-int Image_trace_chaine_1(Image_Desc *im, char *txt, int x, int y,
-			char *nomfonte, RGBA *paper, RGBA *ink)
-{
-int	posx, posy, t_texte, foo;
-int	octet;
-uint8_t	*ptrtxt;
-RGBA	blanc = { 255, 255, 255, 255, 0, 0 };
-RGBA	noir = { 0, 0, 0, 64, 0, 0 };
-
-if (nomfonte==NULL) {
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "trace chaine 1: using loaded font\n");
-#endif
-	}
-else	{
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "trace chaine 1: loading font '%s'\n", nomfonte);
-#endif
-	foo = Image_load_fnt8x8(nomfonte, NULL, 0);
-	}
-
-if (NULL==paper)	paper = &blanc;
-if (NULL==ink)		ink = &noir;
-
-#if DEBUG_LEVEL > 1
-Image_print_rgba("encre", ink, 0);
-Image_print_rgba("papier", paper, 0);
-#endif
-
-t_texte = strlen(txt);
-ptrtxt = (uint8_t *)txt;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "texte  %3d  %s\n", t_texte, txt);
-fprintf(stderr, "papier %3d %3d %3d %3d\n", paper->r, paper->g, paper->b, paper->a);
-fprintf(stderr, "encre  %3d %3d %3d %3d\n", ink->r, ink->g, ink->b, ink->a);
-#endif
-
-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);
-		break;
-		}
-	Image_trace_caractere_2(im, priv_fonte, posx, posy, octet, paper, ink);
-	posx += 8;
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/* new --> Sun Feb  2 20:17:34 CET 2014   */
-/*
- *	Don't forget to load a font, eg :
- *	Image_load_fnt8x8("8x8thin", NULL, 0);
- */
-int
-Image_trace_big_char_0(Image_Desc *im, int x, int y, int code, int kx, int ky)
-{
-int		foo, bar;
-uint8_t		octet;
-Image_Rect	rect;
-RGBA		paper, ink;
-
-#if DEBUG_LEVEL
-char		buff[20];
-if (isprint(code))	sprintf(buff, "'%c'", code);
-else			sprintf(buff, "%02xh", code);
-fprintf(stderr, "%s ( %p %4d %4d   %s   %d %d )\n", __func__, im,
-				x, y, buff, kx, ky);
-#endif
-
-if ( (code < 0) || (code > 255))
-	{
-	fprintf(stderr, "in %s, code (%d) is invalid\n", __func__, code);
-	return BAD_PARAMETER;
-	}
-
-Image_load_fnt8x8("8x8thin", NULL, 0);
-
-paper.r = paper.g = paper.b = 0;
-ink.r = ink.g = ink.b = 255;
-
-rect.w = kx, rect.h = ky;
-
-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++)
-		{
-		rect.x = (bar * kx) + x;
-		rect.x = ((8-bar)*kx) + x;
-		if (octet & 1)
-			{
-#if DEBUG_LEVEL > 1
-			Image_plotRGB(im, x+8-bar, y+foo, 255, 255, 255);
-#endif
-			Image_paint_rect(im, &rect, 255, 198, 0);
-			Image_draw_rect(im, &rect, 0, 0, 80);
-			}
-		octet >>= 1;
-		}
-	}
-
-im->modified++;
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/

Lib/text1.c

@@ -1,98 +0,0 @@
-/*
-		text1.c
-		-------
-*/
-
-#include  <stdio.h>
-#include  <string.h>
-#include  <unistd.h>
-#include  <stdlib.h>
-
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	parameter 'flags' is not used (reserved), must be 0.
- */
-int
-Image_txt1_box_0(Image_Desc *img, char *txt, int x, int y, int w, 
-			RGBA *paper, RGBA *ink, int flags)
-{
-int		foo, lstr;
-Image_Rect	rect;
-
-if (flags != 0)
-	{
-	fprintf(stderr, "%s : wrong flags: 0x%x\n", __func__, flags);
-	return WRONG_FLAG;
-	}
-if (w < 0)
-	{
-	fprintf(stderr, "Ahem, w (%d) is < 0 ?\n", w);
-	}
-
-lstr = strlen(txt);
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "Txt1 box 0: taille texte: %d\n", lstr);
-Image_print_rgba("Papier", paper, 0);
-Image_print_rgba("Encre",  ink, 0);
-#endif
-
-rect.x = x;	rect.y = y;
-rect.h = 8 + (w*2);
-rect.w = (lstr*8) + (w*2);
-
-foo = Image_paint_rect(img, &rect, paper->r, paper->g, paper->b);
-if (foo)
-	Image_print_error("txt box 0: paint rect: ", foo);
-
-foo = Image_trace_chaine_1(img, txt, x+w, y+w, "libimage.fonte", paper, ink);
-if (foo)
-	Image_print_error("txt box 0: trace chaine 0: ", foo);
-
-foo = Image_draw_rect(img, &rect, ink->r, ink->g, ink->b);
-if (foo)
-	Image_print_error("txt box 0: draw rect: ", foo);
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/* new --> Sun Feb  2 20:12:07 CET 2014   */
-/*
- *	Don't forget to load a font, eg :
- *	Image_load_fnt8x8("8x8thin", NULL, 0);
- */
-int	Image_txt1_big_0(Image_Desc *im, char *txt, int x, int y,
-						int xf, int yf)
-{
-int		foo, idx, len;
-int		xpos;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p \"%s\" %d %d %d %d )\n", __func__, im,
-				txt, x, y, xf, yf);
-#endif
-
-len = strlen(txt);
-#if DEBUG_LEVEL
-fprintf(stderr, "  len = %d\n", len);
-#endif
-
-xpos = x;
-for (idx=0; idx<len; idx++)
-	{
-#if DEBUG_LEVEL > 2
-	fprintf(stderr, "    idx %3d   ch 0x%02x  x %d\n",
-				idx, txt[idx], xpos);
-#endif
-	foo = Image_trace_big_char_0(im, xpos, y, txt[idx], xf, yf);
-#if DEBUG_LEVEL
-	fprintf(stderr, "Image_trace_big_char_0 -> %d\n", foo);
-#endif
-	xpos += (xf * 8);
-	}
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/

Lib/text16x24.c

@@ -1,327 +0,0 @@
-/*
- *		textes en 16x24
- *		---------------
- */
-
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <ctype.h>
-#include  <string.h>
-#include  "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-typedef struct	{
-	short		flags;
-	uint16_t	bits[24];
-	} Char_16x24;
-
-/* go, go, go, have a global var */
-Char_16x24	chars_16x24[256];
-
-/*::------------------------------------------------------------------::*/
-/*
-	il n'y a encore rien dans cette fonction, car je suis en train
-	de construire un éditeur de fonte adapté a _mes_ besoins.
-	dès qu'il commencera à être utilisable, et surtout dès que les
-	spécifications du format de fichier seront relativement figées,
-	je commencerais à coder la chose.
-*/
-int	Image_t16x24_binload(char *fontname, uint8_t *zone, int flag)
-{
-
-fprintf(stderr, "Don't know how to load '%s' in binary mode\n", fontname);
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/* WARNING: this function is a work in progress */
-
-int	Image_t16x24_txtload(char *fontname, uint8_t *zone, int flags)
-{
-FILE		*fp;
-int		numchar;
-int		foo, bar, x, y, eol, mask;
-char		ligne[20+1];
-uint16_t		mot;
-
-if ( NULL == (fp=Image_must_fopen(fontname, "r", 0)) )
-	{
-	fprintf(stderr, "can't open %s\n", fontname);
-	return FILE_NOT_FOUND;
-	}
-
-#if DEBUG_LEVEL 
-fprintf(stderr, "%s: trying to load '%s' (%d)\n", __func__, fontname, flags);
-#endif
-
-/* 16 juin 2015 : now we can erase the whole font by
-                  setting bit 0 of flags to one */
-if (flags & 1) {
-	fprintf(stderr, "erasing 16x24 font at %p\n", chars_16x24);
-	memset(chars_16x24, 0, sizeof(chars_16x24));
-	}
-
-while ( 1 == fscanf(fp, "%d\n", &numchar) )
-	{
-	if ( (numchar<0) || (numchar>255) )
-		{
-		fprintf(stderr, "char %d out of range\n", numchar);
-		break;
-		}
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "-------   Char %3d    '%c'\n", numchar,
-				isprint(numchar) ? numchar : ' ');
-#endif
-
-	for (y=0; y<24; y++)
-		{
-		/* lecture d'une ligne d'ascii-pixels */
-		memset(ligne, '\0', 20);
-		if ( NULL==fgets(ligne, 20, fp) )
-			{
-			fprintf(stderr, "EOF ?\n");
-			}
-		foo = strlen(ligne);
-		eol = ligne[16];
-		if (foo!=17 || eol!='\n')
-			{
-			fprintf(stderr, "%s: bad line: %3d  %3d  %3d\n",
-					__func__, y, foo, eol);
-			fprintf(stderr, "   [%s]\n", ligne);
-			abort();	/* very hard, no ? XXX */
-			}
-		mask = 0x8000;
-		mot = 0;
-		for (x=0; x<16; x++)
-			{
-			if (ligne[x]=='*' || ligne[x]=='0')
-				{
-				mot |= mask;
-#if DEBUG_LEVEL > 1
-				putchar('O');
-#endif
-				}
-/* ahem, ne serait-il pas bon de filtrer un peu plus les
- * caracteres indesirables ? */
-#if DEBUG_LEVEL > 1
-			else
-				putchar(' ');
-#endif
-			mask >>= 1;
-			}
-#if DEBUG_LEVEL > 1
-		printf("  |   %04x\n", mot);
-#endif
-		chars_16x24[numchar].bits[y] = mot;
-		}
-	/* fin de la boucle sur les caracteres dans le fichier */
-	}
-
-fclose(fp);
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-int Image_t16x24_pltch_exp(Image_Desc *img, int lettre, int xpos, int ypos)
-{
-int	x, y;
-uint16_t	mask;
-
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s: lettre %3d   '%c'     %4d %4d\n", __func__, lettre,
-			isprint(lettre) ? lettre : ' ', xpos, ypos);
-#endif
-
-for (x=0; x<16; x++)
-	for (y=0; y<24; y++)
-		Image_plotRGB(img, x+xpos, y+ypos, 60, 60, 80);
-for (y=0; y<24; y++)
-	{
-	mask = 0x8000;
-	for (x=0; x<16; x++)
-		{
-		if (chars_16x24[lettre].bits[y] & mask)
-			{
-#if DEBUG_LEVEL > 2
-			putchar('X');
-#endif
-			Image_plotRGB(img, x+xpos, y+ypos, 200, 200, 250);
-			}
-#if DEBUG_LEVEL > 2
-		else putchar('-');
-#endif
-		mask >>= 1;
-		}
-#if DEBUG_LEVEL > 2
-	putchar('\n');
-#endif
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-int	Image_t16x24_pltch_1(Image_Desc *img, int lettre, int xpos, int ypos,
-					RGBA *pap, RGBA *ink, int flags)
-{
-int		x, y, rs, gs, bs;
-int		rp, gp, bp;
-int		x2, y2;
-uint16_t		mask;
-
-/* safety plug */
-
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s: ltr %3d  '%c'     %4d %4d\n", __func__, lettre,
-			isprint(lettre) ? lettre : ' ', xpos, ypos);
-#endif
-
-for (y=0; y<24; y++)
-	{
-	mask = 0x8000;
-	y2 = y + ypos;
-	for (x=0; x<16; x++)
-		{
-		x2 = x + xpos;
-		Image_getRGB(img, x2, y2, &rs, &gs, &bs);
-		if (chars_16x24[lettre].bits[y] & mask)
-			{
-#if DEBUG_LEVEL > 1
-			putchar('O');
-#endif
-                        rp = ((rs*(255-ink->a))+(ink->r*ink->a)) / 255;
-                        gp = ((gs*(255-ink->a))+(ink->g*ink->a)) / 255;
-                        bp = ((bs*(255-ink->a))+(ink->b*ink->a)) / 255;
-			}
-		else
-			{
-#if DEBUG_LEVEL > 1
-			putchar('.');
-#endif
-                        rp = ((rs*(255-pap->a))+(pap->r*pap->a)) / 255;
-                        gp = ((gs*(255-pap->a))+(pap->g*pap->a)) / 255;
-                        bp = ((bs*(255-pap->a))+(pap->b*pap->a)) / 255;
-			}
-		Image_plotRGB(img, x2, y2, rp, gp, bp);
-		mask >>= 1;
-		} /* finbo x */
-#if DEBUG_LEVEL > 1
-	putchar('\n');
-#endif
-	} /* finbo y */
-
-return FUNC_IS_ALPHA;/* BETIC ? */
-}
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-int Image_t16x24_pltstr_1(Image_Desc *img, char *str, int x, int y,
-                                         RGBA *paper, RGBA *ink, int flags)
-{
-int	len, foo;
-
-len = strlen(str);
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: '%s' at %d,%d\n", __func__, str, x, y);
-#endif
-
-for (foo=0; foo<len; foo++)
-	{
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "%4d  %c\n", foo, str[foo]);
-#endif
-	Image_t16x24_pltch_1(img, str[foo], x+(foo*16), y, paper, ink, flags);
-	}
-
-return FUNC_IS_ALPHA;    /* BETIC ? */
-}
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-#define T_ZONE  (256*24*2)	/* please explain this magic number */
-
-int	Image_t16x24_essai(char *fontname, char *texte, char *tganame)
-{
-Image_Desc	*img;
-int		foo;
-int		ltxt, largeur;
-
-fprintf(stderr, "*** essai fonte 16x24:  %s -> %s\n", fontname, tganame);
-fprintf(stderr, "    texte -> '%s'\n", texte);
-
-foo = Image_t16x24_txtload(fontname, NULL, 0);
-Image_print_error("fonte 16x24, txtload", foo);
-
-ltxt = strlen(texte);
-largeur = 16 * ltxt;
-
-img = Image_alloc(largeur, 24, 3);
-if (NULL == img)
-	{
-	abort();
-	}
-Image_clear(img, 0, 0, 0);
-
-for (foo=0; foo<ltxt; foo++)
-	{
-	Image_t16x24_pltch_exp(img, texte[foo], foo*16, 0);
-	}
-
-foo = Image_TGA_save(tganame, img, 0);
-Image_DeAllocate(img);
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-#define S_X (34)
-#define S_Y (37)
-#define W_IMG (8+(16*S_X))
-#define H_IMG (10+(16*S_Y))
-int	Image_t16x24_chars_map(char *fontname, char *tganame, int flag)
-{
-Image_Desc	*img;
-int		foo, ix, iy, ichar;
-int		px, py;
-char		chaine[42];
-RGBA		paper, ink;
-
-foo = Image_t16x24_txtload(fontname, NULL, 1);
-Image_print_error("fonte 16x24, txtload", foo);
-
-img = Image_alloc(W_IMG, H_IMG, 3);
-if (NULL == img)
-	{
-	abort();
-	}
-Image_clear(img, 0, 0, 0);
-
-Image_load_fnt8x8("8x8thin", NULL, 0);
-
-paper.r = paper.g = paper.b = paper.a = 0;
-ink.r = ink.g = ink.b = 192; ink.a = 255;
-
-ichar = 0;
-for (ix=0; ix<16; ix++)
-	{
-	px = 4 + (ix * S_X);
-	for (iy=0; iy<16; iy++)
-		{
-		py = 4 + (iy * S_Y);
-		Image_t16x24_pltch_exp(img, ichar, px+4, py);
-
-		if (flag & 1)
-			sprintf(chaine, "$%02x", ichar);
-		else
-			sprintf(chaine, "%3d", ichar);
-			
-		Image_trace_chaine_1(img, chaine, px, py+25, NULL,
-							&paper, &ink);
-		ichar ++;
-		}
-	}
-
-foo = Image_TGA_save(tganame, img, 0);
-Image_DeAllocate(img);	free(img);
-
-return 42;
-}
-/*::------------------------------------------------------------------::*/

Lib/warp0.c

@@ -1,87 +0,0 @@
-/*
-                    warp0.c
-		---------------
-		diverses deformations d'image.
-*/
-
-#include   <stdio.h>
-#include   <math.h>
-
-#include   "../tthimage.h"
-
-#ifndef DEBUG_LEVEL
-#define DEBUG_LEVEL 1
-#endif
-
-/*::------------------------------------------------------------------::*/
-/*
- *	bon, caisse que peut bien faire ce truc ?
- */
-int
-Image_warp_essai_0(Image_Desc *src, Image_Desc *dst, double angle,
-				int xc, int yc)
-{
-int	x, y, r, g, b;
-long	lfoo;
-double	arad, dheight, dwidth, tmax, dist, va;
-int	ofx, ofy;
-
-dheight = (double)dst->height;
-dwidth  = (double)dst->width;
-
-lfoo = ((dst->height*dst->height)+(dst->width*dst->width));
-tmax = sqrt((double)lfoo) / 2.0;
-va = angle / 360.0;
-
-fprintf(stderr, "%s : %d,%d dh = %f  dw = %f  tmax = %f\n", __func__, 
-			xc, yc, dheight, dwidth, tmax);
-
-for (y=0; y<dst->height; y++)
-	{
-	/*
-	printf("------- Ligne %d -----------------\n", y);
-	*/
-	arad = ((double)y / dheight) * M_PI;	
-
-	for (x=0; x<dst->width; x++)
-		{
-		dist = (double)x / dwidth;
-
-		ofx = xc + (int)(sin(arad)*dist*tmax);
-		ofy = yc + (int)(cos(arad)*dist*tmax);
-
-		/*
-		printf("%15f  %15f   %6d  %6d\n", arad, dist, ofx, ofy); 
-		*/
-
-		if ( ofx>=0 && ofx<src->width && ofy>=0 && ofy<src->height )
-			{
-			Image_getRGB(src, ofx, ofy, &r, &g, &b);
-			}
-		else
-			{
-			r = g = b = 0;
-			}
-
-		Image_plotRGB(dst, x, y, r, g, b);
-		}
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int
-Image_warp_essai_1(Image_Desc *src, Image_Desc *dst, double angle)
-{
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Warp 1: what I can do here ?\n");
-#endif
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *		voir aussi les module scale.c et warp1.c
- */
-/*::------------------------------------------------------------------::*/

Lib/warp1.c

@@ -1,116 +0,0 @@
-/*
-                    warp1.c
-		_______________
-*/
-
-#include   <stdio.h>
-#include   <math.h>
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/*
- *	Rotation d'image. le parametre 'angle' est en degres.
- */
-int
-Image_center_rotate(Image_Desc *src, Image_Desc *dst, double angle)
-{
-int	xs, ys, xd, yd;
-double	arad, fxs, fys, fxd, fyd;
-double	sincalc, coscalc;
-int	mx, my;
-int	r, g, b;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s : work in progress...\n", __func__);
-#endif
-
-arad = angle/180*M_PI;
-mx = dst->width / 2;
-my = dst->height / 2;
-sincalc = sin(arad);
-coscalc = cos(arad);
-
-for (xd=0; xd<dst->width; xd++)
-	{
-	fxd = (double)(xd-mx);
-	for (yd=0; yd<dst->height; yd++)
-		{
-		fyd = (double)(yd-my);
-		fxs = fxd * coscalc - fyd * sincalc;
-		fys = fxd * sincalc + fyd * coscalc;
-
-		xs = (int)fxs + mx;
-		ys = (int)fys + my;
-
-		if (xs>=0 && xs<src->width && ys>=0 && ys<src->height)
-			{
-			/* Image_getRGB(src, xs, ys, &r, &g, &b); */
-			r = (src->Rpix[ys])[xs];
-			g = (src->Gpix[ys])[xs];
-			b = (src->Bpix[ys])[xs];
-			}
-		else
-			{ r = g = b = 142; }
-
-		/* Image_plotRGB(dst, xd, yd, r, g, b); */
-		(dst->Rpix[yd])[xd] = r;
-		(dst->Gpix[yd])[xd] = g;
-		(dst->Bpix[yd])[xd] = b;
-		}
-	}
-
-return FUNC_IS_BETA;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	La meme chose, en gros...
- *	Sauf qu'on pourrait theoriquement choisir la position du
- *	point de rotation.
- *
- *					reste plus qu'à coder...
- */
-int
-Image_center_rotate_xy(Image_Desc *src, Image_Desc *dst, double angle,
-						double x, double y)
-{
-int	foo, xd, yd;
-double	arad, fxs, fys, fxd, fyd;
-double	sincalc, coscalc;
-int	mx, my;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Center Rotate XY: work in progress...\n");
-#endif
-
-fprintf(stderr, "%s on %p at %g,%g\n", __func__, src, x, y);
-
-arad = angle/180*M_PI;
-mx = dst->width / 2;
-my = dst->height / 2;
-sincalc = sin(arad);
-coscalc = cos(arad);
-
-fxs = fys = 0.0;	/* ? hein ? */
-foo = 0;
-
-for (xd=0; xd<dst->width; xd++)
-	{
-	fxd = (double)(xd-mx);
-	for (yd=0; yd<dst->height; yd++)
-		{
-		fyd = (double)(yd-my);
-
-
-		}
-	}
-
-			/* MAIS C'EST PAS ENCORE FINI CE TRUC ? */
-			/* 4 mai 2007: ben non, ya rien :) */
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *		voir aussi les modules scale.c et warp0.c
- */
-/*::------------------------------------------------------------------::*/

Lib/warp2.c

@@ -1,88 +0,0 @@
-/*
-                    warp2.c
-		---------------
-*/
-
-#include   <stdio.h>
-#include   <math.h>
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/* 
- *	Bon, ça marche avec des déplacements positifs, mais pour
- *	revenir en arrière, on fait comment ?
- */
-int
-Image_shift_xy(Image_Desc *src, Image_Desc *dst, int ox, int oy)
-{
-int	x, y;
-int	x2, y2, foo;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "*** Image_shift_xy: work in progress...\n");
-fprintf(stderr, "src=%p dst=%p ox=%d oy=%d\n", src, dst, ox, oy);
-#endif
-
-if ( src == dst )
-	{
-	fprintf(stderr, "Image shift xy: can't overwrite, sorry\n");
-	return IMG_OVERWRITE;
-	}
-
-if ( (foo=Image_compare_desc(src, dst)) )
-    {
-    fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
-    return foo;
-    }
-
-if ( (ox<0) || (ox>=src->width) )
-	{
-	fprintf(stderr, "Image shift xy: param ox %d out of range\n", ox);
-	return INVALID_PARAM;
-	}
-if ( (oy<0) || (oy>=src->height) )
-	{
-	fprintf(stderr, "Image shift xy: param oy %d out of range\n", oy);
-	return INVALID_PARAM;
-	}
-
-for (y=0; y<dst->height; y++)
-	{
-	y2 = (y+oy) % src->height;
-	for (x=0; x<dst->width; x++)
-		{
-		x2 = (x+ox) % src->width;
-		Image_pixel_copy(src, x, y, dst, x2, y2);
-		}
-	}
-
-return FUNC_IS_BETA;		/* et elle coredumpe ? */
-}
-/*::------------------------------------------------------------------::*/
-/* OPTIMIZED FOR SPEED */
-int Image_shift_x(Image_Desc *src, Image_Desc *dst, int ox)
-{
-
-#if DEBUG_LEVEL
-fprintf(stderr, "*** %s : work in progress...\n", __func__);
-fprintf(stderr, "%p -> sX(%d) -> %p\n", src, ox, dst);
-#endif
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/* OPTIMIZED FOR SPEED */
-int Image_shift_y(Image_Desc *src, Image_Desc *dst, int oy)
-{
-#if DEBUG_LEVEL
-fprintf(stderr, "*** %s : work in progress...\n", __func__);
-fprintf(stderr, "%p -> sY(%d) -> %p\n", src, oy, dst);
-#endif
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *		voir aussi les modules scale.c et warp[0|1|3].c
- */
-/*::------------------------------------------------------------------::*/

Lib/warp3.c

@@ -1,62 +0,0 @@
-/*
-                    warp3.c
-		---------------
-*/
-
-#include   <stdio.h>
-#include   <math.h>
-#include   "../tthimage.h"
-
-/*::------------------------------------------------------------------::*/
-/* 
- *	travail basé sur un PDF dont l'URL a été postée dans la 
- *	tribune de la buvette.
- *
- *	L'auteur est Gernot Hoffmann.
- */
-int
-Image_interpolate_0(Image_Desc *src, Image_Desc *dst, int ox, int oy)
-{
-int	x, y;
-int	x2, y2, foo;
-
-fprintf(stderr, "*** Image_interpolate_0: work in progress...\n");
-
-if ( src == dst )
-	{
-	fprintf(stderr, "Image interpolate_0: can't overwrite, sorry\n");
-	return IMG_OVERWRITE;
-	}
-
-/*
-		@@@@@@@@@@@@@@
-		PUTAIN SA RACE
-		La police du PDF est pas sortie à l'impression :(
-		@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
-		Et comme le code est incomplet et en Pascal, je ne
-		sais pas trop quoi en faire. Beueueueh.
-		@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
-*/
-
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-/*     new 11 janvier 2009 - avenue St Exupery */
-int
-Image_interpolate_2(Image_Desc *src, Image_Desc *dst, RGBA *rgba)
-{
-int		x, y;
-
-if (NULL==rgba)
-	{
-	fprintf(stderr, "Using default RGBA in %s...\n", __func__);
-	}
-
-return FULL_NUCKED;
-}
-/*::------------------------------------------------------------------::*/
-/*
- *	voir aussi les modules scale.c, zoom.c et warp[0|1|2].c
- */
-/*::------------------------------------------------------------------::*/

Paramakes.mk

@@ -1,35 +0,0 @@
-#
-#		GLOBAL MAKE CONFIGURATION
-#
-
-DESTDIR=/usr/local
-SHARED_FILES=$(DESTDIR)/share/libimage
-HTML_DIR=$(DESTDIR)/html
-
-#-----------------------------------------------------------------
-#
-#	pour le debuging: option -g
-#	pour le profiling: option -pg
-#	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
-#
-#	--> see file 'PORTING.txt' for porting tips on misc
-#	    architextures (just sparc64 for now)
-#
-
-LIBIMG_OPT=-DFORCE_ABORT=1 -DDEBUG_LEVEL=0 -DIMGCOMMENT=0
-CC_OPTS=-Wall -W -g -ansi  -Wmissing-prototypes -fPIC -no-pie
-CC_HACKS=-DNEED_ALLOCA_H 
-CFLAGS= $(CC_OPTS)			\
-	$(LIBIMG_OPT)			\
-	$(CC_HACKS) 			\
-	-DDESTDIR=\"$(DESTDIR)\"	\
-	-DSHAREDIR=\"$(SHARED_FILES)\"	\
-	-DCC_OPTS=\"'$(CC_OPTS)'\"
-LINKOPT=-lm
-RANLIB=wc -c
-
-# modify it 'as you like'
-AR=ar 

Tests/README.md

@@ -1,3 +0,0 @@
-# Some useless tests
-
-YMMV !

Tools/Makefile

@@ -1,24 +0,0 @@
-#-----------------------------------------------------------------
-#
-#	Fabrication des outils - nouvelle version 26 juin 2022
-#
-#-----------------------------------------------------------------
-
-include ../Paramakes.mk
-
-DEPS = ../tthimage.h Makefile 
-
-all:	tga_tools
-
-#-----------------------------------------------------------------
-
-fonctions.o:	fonctions.c
-	gcc $(CFLAGS) -c $< 
-
-#-----------------------------------------------------------------
-
-tga_tools:	tga_tools.c $(DEPS) fonctions.o
-	gcc $(CFLAGS) $< ../libimage.a fonctions.o -o $@
-
-
-#-----------------------------------------------------------------

Tools/fonctions.c

@@ -1,430 +0,0 @@
-/*
-		T G A _ O U T I L S
-		-------------------
-
-	fonctions communes a tous les outils - new 11 juin 2002
-
-*/
-
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <string.h>
-
-/* non portable but useful function */
-char *strdup(const char *s);
-
-#define IN_FONCTION
-#include  "tga_outils.h"
-
-/*::------------------------------------------------------------------::*/
-int
-cherche_mot_clef(char *mot, mot_clef *liste, int *pmode, int *pnbarg)
-{
-int		idx = 0;
-
-idx = 0;
-while (liste[idx].nom != NULL)
-	{
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "check %12s  %8s\n",	liste[idx].nom,
-						liste[idx].ptypes);
-#endif
-	if ( ! strcmp(liste[idx].nom, mot) )
-		{
-		*pmode = liste[idx].code;
-		*pnbarg = strlen(liste[idx].ptypes);	
-#if DEBUG_LEVEL > 1
-		fprintf(stderr, "found! mode %d nbpar %d\n", *pmode, *pnbarg);
-		sleep(1);
-#endif
-		return idx;
-		}
-	idx++;
-	}
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s : %s not found\n", __func__, mot);
-#endif
-
-return -1;
-}
-/*::------------------------------------------------------------------::*/
-int
-liste_mots_clefs(mot_clef *liste, int flag)
-{
-mot_clef	*pmc;
-
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s ( %p %d )\n", __func__, liste, flag);
-#endif
-
-if (42 != flag) {
-	fprintf(stderr, "UH ? flag is not the universal answer ?\n");
-	}
-
-pmc = liste;
-
-printf("  commande  | type arg |  explication\n");
-printf("------------+----------+------------------------------------\n");
-while (pmc->nom != NULL)
-	{
-	if (pmc->aide != NULL)
-		printf(" %-10s | %-8s |  %s\n",
-			pmc->nom, pmc->ptypes, pmc->aide);
-	pmc++;
-	}
-printf("------------+----------+------------------------------------\n");
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/*
- * INPUT	str	string to scan for an integer
- * 		pval	pointer to the retrun value
- * 		k	* not used *
- *
- * OUTPUT	1	successfuly make a conversion
- * 		0	strange error occured :(
- */
-int	parse_int_param(char *str, int *pval, int k)
-{
-long	lfoo;
-int	val;
-
-val = (int)(lfoo = strtol(str, NULL, 0));
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s: %s: '%s'  ->  %ld  ->  %d\n",
-		__FILE__, __func__, str, lfoo, val);
-#endif
-
-*pval = val;
-
-return 1;
-}
-
-/*::------------------------------------------------------------------::*/
-/*	input:		str	string to scan for four csv int
-			prect	rectangle struct who need datas
-			k	* not used *
-	output		1	all correct
-			2	invalid string
-27 janvier 2014
-*/
-int	parse_rect_param(char *str, Image_Rect *prect, int k)
-{
-char		*cptr;
-int		idx, foo, val;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s '%s' to %p\n", __func__, str, prect);
-#endif
-
-if (k) fprintf(stderr, "%s : k is %d, but must be 0\n", __func__, k);
-
-memset(prect, 0, sizeof(Image_Rect));
-
-cptr = strdup(str);
-#if DEBUG_LEVEL
-fprintf(stder, "copie dans cptr %p\n", cptr);
-#endif
-
-idx = 0;
-cptr = strtok(cptr, ",");
-while (NULL != cptr)	{
-	fprintf(stderr, "%3d %p = '%s'\n", idx, cptr, cptr);
-	foo = sscanf(cptr, "%d", &val);
-	fprintf(stderr, "val = %d\n", val);
-	switch (idx) {
-		case 0:		prect->x = val;		break;
-		case 1:		prect->y = val;		break;
-		case 2:		prect->w = val;		break;
-		case 3:		prect->h = val;		break;
-		}
-	cptr = strtok(NULL, ",");
-	idx++;
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-
-static Param		params[NB_PARAMS];
-
-int 
-parse_parametres(int argc, char *argv[], char *types, int prem)
-{
-int	foo, idxt;
-int	entier;
-double	flottant;
-char	*cptr;
-
-#if DEBUG_LEVEL 
-fprintf(stderr, "Parse params: types '%s' debut %d\n", types, prem);
-#endif
-
-/*
- *	init de la table des paramètres.
- */
-for (foo=0; foo<NB_PARAMS; foo++) {
-	params[foo].type = '?';
-	}
-
-for (foo=prem, idxt=0; foo<argc; foo++, idxt++)
-	{
-#if DEBUG_LEVEL
-	fprintf(stderr, "\t%d/%d\t%c\t%s\n", foo, idxt, types[idxt], argv[foo]);
-#endif
-	switch (types[idxt])
-	{
-	case 'c':
-		if (strlen(argv[foo])!=1)
-			{
-			fprintf(stderr, "bad length of char param\n");
-			}
-		else
-			{
-#if DEBUG_LEVEL
-			fprintf(stderr, "char param = %d\n", *argv[foo]);
-#endif
-			params[idxt].type = 'c';
-			params[idxt].p.i = *argv[foo];
-			}
-		break;
-	case 'i':
-		/*
- 		 * En fait, ici, il serait bon de parser aussi les
- 		 * parametres donnes en hexadecimal.
- 		 */
-		if (parse_int_param(argv[foo], &entier, 0)==1)
-			{
-			params[idxt].type = 'i';
-			params[idxt].p.i = entier;
-			}
-		else
-			{
-			fprintf(stderr, "ERR parse int param %s\n", argv[foo]);
-			exit(5);
-			}
-		break;
-
-	case 's':
-#if DEBUG_LEVEL
-		fprintf(stderr, "%s: case 's' : %p\n", __func__, argv[foo]);
-#endif
-		if ((cptr=strdup(argv[foo]))!=NULL)	
-			{
-			params[idxt].type = 's';
-			params[idxt].p.s = cptr;
-			}
-		else
-			{
-			fprintf(stderr, "ERR parse param %s\n", argv[foo]);
-			exit(5);
-			}
-		break;
-
-	case 'd':
-		/* the 'd' is for 'double precision', not for 'decimal' */
-		if (sscanf(argv[foo], "%lf", &flottant)==1)
-			{
-			params[idxt].type = 'd';
-			params[idxt].p.d = flottant;
-#if DEBUG_LEVEL
-			fprintf(stderr, "at foo=%d, val is %f %g\n",
-						foo,	flottant, flottant);
-#endif
-			}
-		else
-			{
-			fprintf(stderr,"ERR parse float param %s\n",argv[foo]);
-			exit(5);
-			}
-		break;
-
-	case 'f':
-		/* the 'f' is for 'flag', not for 'float' */
-		switch(argv[foo][0])
-			{
-			case '0': case 'f': case 'F': case 'n': case 'N':
-				params[idxt].type = 'f';
-				params[idxt].p.i = 0;
-				break;
-			case '1': case 't': case 'T': case 'y': case 'Y':
-				params[idxt].type = 'f';
-				params[idxt].p.i = 1;
-				break;
-			default:
-				fprintf(stderr, "bad flag %s\n", argv[foo]);
-				exit(5);
-			}
-		break;
-
-	case 'R':
-		fprintf(stderr, "'Rect' parser not implemented\n");
-		exit(6);
-
-	default:
-		fprintf(stderr, "partype #%d '%c' invalid\n",
-					idxt, types[idxt]);
-		exit(5);
-		}
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/*	affichage de la liste des parametres trouves			*/
-
-void print_parametres(void)
-{
-int	foo;
-printf("   +------+-----+\n");
-printf("   | parameters |\n");
-printf("   +------+-----+\n");
-for (foo=0; foo<NB_PARAMS; foo++)
-	{
-	printf("   |  %2d  |  %c  |\n", foo, params[foo].type);
-	}
-printf("   +------+-----+\n");
-fflush(stdout);
-}
-
-/*::------------------------------------------------------------------::*/
-/*
- *	fonctions de récuperation d'un paramètre.
- */
-
-int	GIP(int rang)
-{
-if (rang<0 || params[rang].type!='i')
-	{
-	fprintf(stderr, "erreur GIP %d\n", rang);
-	exit(5);
-	}
-return params[rang].p.i;
-}
-
-int	GCP(int rang)
-{
-if (rang<0 || params[rang].type!='c')
-	{
-	fprintf(stderr, "erreur GCP %d\n", rang);
-	exit(5);
-	}
-return params[rang].p.i;
-}
-
-/* get an 'int' parameter with a default value */
-int	GIPdef(int rang, int def)
-{
-#if DEBUG_LEVEL
-fprintf(stderr, "Warning !   %s is not tested\n", __func__);
-#endif
-if (rang<0 || params[rang].type!='i')
-	{
-	return def;
-	}
-return params[rang].p.i;
-}
-
-char *	GSP(int rang)
-{
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "GetStringParameter(%d)\n", rang);
-#endif
-if (rang<0 || params[rang].type!='s')
-	{
-	fprintf(stderr, "erreur GSP %d\n", rang);
-	exit(5);
-	}
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "GetStringParameter -> %s\n", params[rang].p.s);
-#endif
-return params[rang].p.s;
-}
-
-double	GDP(int rang)
-{
-if (rang<0 || params[rang].type!='d')
-	{
-	fprintf(stderr, "erreur GDP %d\n", rang);
-	exit(5);
-	}
-return params[rang].p.d;
-}
-
-int	GFP(int rang)
-{
-if (rang<0 || params[rang].type!='f')
-	{
-	fprintf(stderr, "erreur GFP %d\n", rang);
-	exit(5);
-	}
-return params[rang].p.i;
-}
-
-/*::------------------------------------------------------------------::*/
-int
-must_be_verbose(void)
-{
-char	*envvar;
-
-envvar = getenv(NOM_VAR_ENV_VERBOSE);
-if ((envvar!=NULL) && !strcmp(envvar, "yes"))
-	{
-#if DEBUG_LEVEL > 1
-	fprintf(stderr, "HA HA HA ! pid:%d MUST BE VERBOSE !\n", getpid());
-#endif
-	return 1;
-	}
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-int
-dump_command_line(int argc, char *argv[], int force)
-{
-char	*envvar;
-int	flag=0, foo;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : %s, argc=%d\n", __func__, argv[0], argc);
-#endif
-
-envvar = getenv(NOM_VAR_ENV_VERBOSE);
-if ( (envvar!=NULL) && !strcmp(envvar, "yes") )		flag = 1;
-
-if (flag || force)
-	{
-	fprintf(stderr, "TGA(%d) %d arg:", getpid(), argc);
-	for (foo=0; foo<argc; foo++)
-		fprintf(stderr, " %s", argv[foo]);
-	fprintf(stderr, "\n");
-	}
-return flag;
-}
-/*::------------------------------------------------------------------::*/
-int	set_new_seed(int k)
-{
-char		*ptr;
-long		seed;
-
-if (NULL==(ptr=getenv("FIXED_SEED"))) {
-	/* no fixed seed in context, doing semi-random */
-	srand(getpid());
-#if DEBUG_LEVEL
-	fprintf(stderr, "no FIXED_SEED, first rand is number : %d\n", rand());
-#endif
-	}
-else	{
-	/* try to parse the env var */
-	seed = strtol(ptr, NULL, 0);
-#if DEBUG_LEVEL
-	fprintf(stderr, "%s : strtol(%s) -> %ld\n",
-				__func__, ptr, seed);
-#endif
-	srand(seed);
-	}
-	
-return rand();
-}
-/*::------------------------------------------------------------------::*/

Tools/tga_outils.h

@@ -1,102 +0,0 @@
-/*
-		tga_outils.h
-		------------
-*/
-
-#include  <unistd.h>
-
-#include  "../tthimage.h"
-
-#define  TGA_OUTILS_VERSION   "0.58"
-/*
- *	13 Dec 2001: v0.11 a cause du 'mustopen' pour les palettes.
- *	11 Fev 2002: v0.12 a cause du '-ansi' (hein Kerdeuzz, on y vient)
- *	21 Nov 2002: v0.13 a cause du parser de paramètres.
- *	14 Jan 2006: v0.14 parce que je remet le truc dans le net.
- *	05 Jan 2007: v0.15 pour etre synchrone avec la doc.
- *	11 Dec 2007: v0.22 pour le parser de parametres (hexadecimal)
- *	05 May 2009: v0.36 grand nettoyage du code en chantier 
- *	27 Dec 2009: v0.42 prise en compte des champs d'altitude.
- *	06 Mar 2010: v0.43 introduction du 'df3 tool'.
- *	27 Jan 2014: V0.52 added : 'parse_rect_param'.
- */
-
-#define TGA_OUTILS_COPYLEFT "(dwtfywl) TontonTh 2018"
-#define TGA_WWW_SITE "http://la.buvette.org/devel/libimage/"
-
-#define PERR(txt) fprintf(stderr, "\t| %s\n", (txt))
-#define PERL fprintf(stderr, "\t+-----------------------------------------\n")
-
-#define NOM_VAR_ENV_VERBOSE "TGA_OUTILS_VERBOSE"      /* flag ON = "yes" */
-#define NOM_VAR_ENV_TIMING  "TGA_OUTILS_TIMING"       /* flag ON = "yes" */
-
-int	must_be_verbose(void);
-int     set_new_seed(int k);
-
-/*::------------------------------------------------------------------::*/
-/*
- *	structure de description d'un mot-clef
- *	--------------------------------------
- *
- *	types des parametres (chaine pointée par ptype)
- *
- *		i	entier 32 bits / char parameter
- *		s	chaine de caractères
- *		d	double flottant
- */
-typedef struct 
-	{
-	char	*nom;
-	int	code;
-	char   *ptypes;		/* type des paramètres */
-	char   *aide;
-	char	*longhelp;
-	} mot_clef;
-
-#define NB_PARAMS 16		/* max number of allowed parameters */
-
-/*
- *	structure contenant un paramètre.
- */
-typedef struct
-	{
-	char	type;
-	union
-		{
-		int	i;
-		char	*s;
-		double	d;
-		} p;
-	} Param;
-
-int cherche_mot_clef(char *mot, mot_clef *liste, int *pmode, int *pnbarg);
-
-/* le flag ne sert a rien, mais il faut le mettre a 42 */
-int liste_mots_clefs(mot_clef *liste, int flag);
-
-int	parse_int_param(char *str, int *pval, int k);
-int	parse_rect_param(char *str, Image_Rect *prect, int k);
-
-int	parse_parametres(int ac, char *av[], char *types, int prem);
-void	print_parametres(void);
-
-int	GIP(int rang);
-int	GCP(int rang);
-int	GIPdef(int rang, int def);
-char *	GSP(int rang);
-double	GDP(int rang);
-int	GFP(int rang);			/* get flag */
-
-/*::------------------------------------------------------------------::*/
-/*
- *	fonctions de bavardage
- */
-int dump_command_line(int argc, char *argv[], int force);
-
-/*::------------------------------------------------------------------::*/
-/*
- *	pour plus de details, for more informations
- *	http://la.buvette.org/devel/libimage/img-outils.html
- *	----------------------------------------------------
- */
-

Tools/tga_tools.c

@@ -1,402 +0,0 @@
-/*
- *                                       TGA_TOOLS
- */
-
-#include  <stdio.h>
-#include  <stdlib.h>
-
-#include  "tga_outils.h"
-
-/*::------------------------------------------------------------------::*/
-#define		VERSION		1
-#define		SURFACE		2
-#define		GETDIMS		4
-#define		GETDIMX		5
-#define		GETDIMPOV	6
-#define		GETDIMW		7
-#define		WIDTH		8
-#define		HEIGHT		9
-#define		MK_RGB		10	/* new 22 jan 2014 */
-#define		MK_NOISE	11	/* new 07 fev 2014 */
-#define		GRMINMAX	17	/* min & max in gray level */
-#define		MESSAGE		20
-#define		STRUCTS		21
-#define		HEADER		33
-#define		TIMESTAMP	34
-#define		PRHISTO		35
-#define		TAG7SEG0	40
-
-#define		ENVIRON		50
-/*::------------------------------------------------------------------::*/
-mot_clef commandes[] = 
-{
-{ "version",	VERSION,	"",	"version de la libimage"	},
-{ "surface",	SURFACE,	"s",	"number of pixels"		},
-{ "getdims",	GETDIMS,	"s",	"dim targa '42 33'"		},
-{ "getdimx",	GETDIMX,	"s",	"dim targa '42x33'"		},
-{ "getdimpov",	GETDIMPOV,	"s",	"dim au format POV opt"		},
-{ "getdimweb",	GETDIMW,	"s",	"dim au format HTML"		},
-{ "width",	WIDTH,		"s",	"width of targa"		},
-{ "height",	HEIGHT,		"s",	"height of targa"		},
-{ "grminmax",	GRMINMAX,	"si",	"image.tga K"			},
-{ "message", 	MESSAGE,	"sis",  "tgafname flags 'baratin bla'"	},
-{ "structs",	STRUCTS,	"", 	"display sizeof structs"	},
-{ "header",	HEADER,		"s",	"filename of image"		},
-{ "timestamp",	TIMESTAMP,	"ss",	"filename message"		},
-{ "prhisto",	PRHISTO,	"s",	"filename.tga"			},
-{ "tag7",	TAG7SEG0,	"si",	"fname.tga nnn"			},
-{ "environ",	ENVIRON,	"",	""				},
-{ "mk_rgb",	MK_RGB,		"siiiii", "fname w h r g b"		},
-};
-
-/*::------------------------------------------------------------------::*/
-int
-print_tga_dims(char *filename, int flags)
-{
-int	foo, width, height;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s:%d %s ( %s, %d )\n", __FILE__, __LINE__,
-			__func__, filename, flags);
-#endif
-foo = Image_TGA_get_dims(filename, &width, &height);
-if (foo)
-	{
-	fprintf(stderr, "something is bad with %s : %d\n", filename, foo);
-	Image_print_error("explanation", foo);
-	}
-
-switch(flags)
-	{
-	case 0:
-		printf("%8d %8d\n", width, height);
-		break;
-	case 1:
-		printf("%dx%d\n", width, height);
-		break;
-	case 2:
-		printf(" -w%d -h%d\n", width, height);
-		break;
-	case 3:
-		printf("width=%d height=%d\n",  width, height);
-		break;
-	case 4:
-		printf("%d\n",  width);
-		break;
-	case 5:
-		printf("%d\n",  height);
-		break;
-	default:
-		fprintf(stderr, "bad flag %d in %s\n", flags, __func__);
-		abort();
-		break;			/* unreached ? */
-	}
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-int showheader(char *filename, int flag)
-{
-int		foo;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "Show Header '%s' %d\n", filename, flag);
-#endif
-
-foo = Image_TGA_show_header(filename, 0);
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s got %d\n", __func__, foo);
-#endif
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-int make_a_rgb_tga(char *fname, int w, int h, int r, int g, int b)
-{
-Image_Desc	*img;
-int		foo;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s -> %s : %dx%d, rgb %d,%d,%d\n", __func__, fname, w, h,
-					r, g, b);
-#endif
-
-if (w < 1 || h < 1)
-	{
-	fprintf(stderr, "%s : img dims %d %d ?\n", __func__, w, h);
-	return 666;
-	}
-img = Image_alloc(w, h, 3);
-Image_clear(img, r, g, b);
-foo = Image_TGA_save(fname, img, 0);
-
-return 666;
-}
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-int timestamp(char *fnin, char *fnout, char *txt, int flag)
-{
-int		foo;
-Image_Desc	*src;
-
-#if DEBUG_LEVEL
-fprintf(stderr, "timestamping '%s' to '%s' with '%s'\n", fnin, fnout, txt);
-#endif
-
-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_marque_timestamp(src, txt, NULL, 0);
-#if DEBUG_LEVEL
-if (foo)
-	Image_print_error("marque timestamp --> ", foo);
-#endif
-
-Image_TGA_save(fnout, src, 0);
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-int marque_message(char *fnin, char *fnout, char *txt, int flag)
-{
-int		foo, posx, posy;
-Image_Desc	*src;
-RGBA            ink, pap;
-
-/* some sane default values */
-ink.r = 255, ink.g = 255, ink.b = 100;          ink.a = 255;
-pap.r =  30, pap.g =  30, pap.b = 155;          pap.a = 255;
-posx = posy = 6;
-if (flag) {
-	ink.r = 200, ink.g = 200, ink.b = 200;          ink.a = 255;
-	pap.r =   0, pap.g =   0, pap.b =   0;          pap.a = 127;
-	posx = posy = 0;
-	}
-
-if (must_be_verbose())
-	fprintf(stderr, "%s:\n  '%s' to '%s' with '%s' flg %d\n",	\
-			 __func__, fnin, fnout, txt, flag);
-
-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 DEBUG_LEVEL
-fprintf(stderr, "%s : saving %s\n", __func__, fnout);
-#endif
-
-return foo;
-}
-/*::------------------------------------------------------------------::*/
-int print_histogramme(char *filename, int flags)
-{
-Image_Desc	*src;
-long		hr[256], hg[256], hb[256];
-int		foo;
-
-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)
-	{
-	fprintf(stderr, "tga_tools, calcul histogramme: %d  %s\n",
-						foo, Image_err2str(foo));
-	exit(5);
-	}
-
-for (foo=0; foo<256; foo++)
-	{
-	printf("%3d   %8ld   %8ld   %8ld\n", foo, hr[foo], hg[foo], hb[foo]);
-	}
-
-return 0;
-}
-/*::------------------------------------------------------------------::*/
-/* new 27 mars 2008 - avenue St Exupery */
-int print_environ(void)
-{
-int	foo;
-char	*ptr;
-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<(sizeof(noms)/sizeof(char *)); foo++)
-	{
-	ptr = getenv(noms[foo]);
-	printf("%5d    %-25s  %s\n", foo, noms[foo], ptr);
-	}
-
-return FUNC_NOT_FINISH;
-}
-/*::------------------------------------------------------------------::*/
-int tag_7_segments_0(char *fname, int value)
-{
-int		foo;
-Image_Desc	*src;
-char		buffer[100];
-
-#if DEBUG_LEVEL
-fprintf(stderr, "%s:%s %s %d\n", __FILE__, __func__, fname, value);
-#endif
-
-if ( (src=Image_TGA_alloc_load(fname)) == NULL )
-	{
-	fprintf(stderr, "tga_tools, load of '%s' failed in %s\n",
-					fname, __func__);
-	exit(5);
-	}
-
-sprintf(buffer, "%04d", value);
-foo = Image_7seg_tag0(src, buffer, 0);
-#if DEBUG_LEVEL
-fprintf(stderr, "%s : tagging %s -> %d\n", __func__, fname, foo);
-#endif
-
-foo = Image_TGA_save(fname, src, 0);
-#if DEBUG_LEVEL > 1
-fprintf(stderr, "%s : saving %s -> %d\n", __func__, fname, foo);
-#endif
-
-return -1;
-}
-/*::------------------------------------------------------------------::*/
-int main (int argc, char *argv[])
-{
-int		foo;
-int		idx, mode, nbarg;
-char		* cptr;
-
-dump_command_line(argc, argv, 0);
-
-/* new 4 feb 2014 */
-foo = set_new_seed(42);
-#if DEBUG_LEVEL
-fprintf(stderr, "set new seed -> %d\n", foo);
-#endif
-
-if (1 == argc)
-	{
-	fprintf(stderr, "* tga_tools v 0.1.31 (%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)) )
-	{
-	fprintf(stderr, "action '%s' inconnue.\n", argv[1]);
-	exit(1);
-	}
-#if DEBUG_LEVEL
-fprintf(stderr, "%s commande: idx=%d mode=%d nbarg=%d\n",
-			argv[0], idx, mode, nbarg);
-#endif
-
-#define FIRST_PARAM	2
-foo = parse_parametres(argc, argv, commandes[idx].ptypes, FIRST_PARAM);
-
-switch(mode)
-	{
-	case VERSION:
-		printf("Version des outils: %s  ", TGA_OUTILS_VERSION);
-		printf("-  %s,  %s\n", __DATE__, __TIME__);
-		printf("%s is the swiss knife for Targa files\n", argv[0]);
-		Image_print_version(2);
-		break;
-	case GETDIMS:
-		cptr = GSP(0);
-#if DEBUG_LEVEL
-		fprintf(stderr, "GETDIMS %s\n", cptr);
-#endif
-		foo = print_tga_dims(cptr, 0);
-		break;
-	case GETDIMX:
-		cptr = GSP(0);
-		foo = print_tga_dims(cptr, 1);
-		break;
-	case GETDIMPOV:
-		cptr = GSP(0);
-		foo = print_tga_dims(cptr, 2);
-		break;
-	case GETDIMW:
-		cptr = GSP(0);
-		foo = print_tga_dims(cptr, 3);
-		break;
-	case WIDTH:
-		foo = print_tga_dims(GSP(0), 4);
-		break;
-	case HEIGHT:
-		foo = print_tga_dims(GSP(0), 5);
-		break;
-
-	case HEADER:
-		foo = showheader(GSP(0), 0);
-		break;
-
-	case PRHISTO:
-		foo = print_histogramme(GSP(0), 0);
-		break;
-	case TIMESTAMP:
-		cptr = GSP(0);
-		foo = timestamp(cptr, GSP(0), GSP(1), 0);
-		break;
-	case MK_RGB:
-		cptr = GSP(0);
-		fprintf(stderr, "MK_RGB -> %s\n", cptr);
-		foo = make_a_rgb_tga(cptr, GIP(1), GIP(2),
-				GIP(3), GIP(4), GIP(5));
-		break;
-	case MK_NOISE:
-		cptr = GSP(0);
-		fprintf(stderr, "MK_NOISE -> %s\n", cptr);
-		foo = make_a_rgb_tga(cptr, GIP(1), GIP(2),
-				GIP(3), GIP(4), GIP(5));
-		break;
-	case TAG7SEG0:
-		foo = tag_7_segments_0(GSP(0), GIP(1));
-		break;
-
-	case MESSAGE:
-		cptr = GSP(0);
-#if DEBUG_LEVEL
-		fprintf(stderr, "marque message %p\n", cptr);
-#endif
-		foo = marque_message(cptr, GSP(0), GSP(2), GIP(1));
-#if DEBUG_LEVEL
-		fprintf(stderr, "marque message -> %d\n\n", foo);
-#endif
-		break;
-	case STRUCTS:
-#if DEBUG_LEVEL
-		fprintf(stderr, "going to 'Image_print_sizeof_structs'\n");
-#endif
-		Image_print_sizeof_structs(NULL);
-		break;
-	case ENVIRON:
-		foo = print_environ();
-		break;
-	default:
-		fprintf(stderr, "Hu ho %d ?\n", mode);
-		break;
-	}
-return 0;
-}
-/*::------------------------------------------------------------------::*/

basic_io.c

@@ -21,7 +21,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int	Image_basicIO_teste_boutisme(char *txt)

bitblt.c

@@ -12,7 +12,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

bitplanes.c

@@ -10,7 +10,7 @@
 #include  <string.h>
 #include  <unistd.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 #define VERSION_STRING "5 octobre 2015"
 
@@ -248,7 +248,7 @@ if (NULL==(fp=fopen(fname, "w")))
 	}
 
 fprintf(fp, "P1\n%d %d\n", bp->width, bp->height);
-fprintf(fp, "# written by libtthimage v %s\n# bitplane module '%s'\n",
+fprintf(fp, "# written by libimage v %s\n# bitplane module '%s'\n",
 			IMAGE_VERSION_STRING, VERSION_STRING);	
 
 chariot = 0;

build.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-
-cd Lib
-make foo
-cd ..

calculs.c

@@ -9,7 +9,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*          pour les performances, cette fonction

classif.c

@@ -6,7 +6,7 @@
 #include  <stdio.h>
 #include  <math.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

col_reduc.c

@@ -6,7 +6,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

col_xyz.c

@@ -5,7 +5,7 @@
 #include  <stdio.h>
 #include  <math.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

combine.c

@@ -12,7 +12,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 #ifndef min
 #define min(a,b) ((a)<(b)?(a):(b))

combine2.c

@@ -8,7 +8,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

combine3.c

@@ -7,7 +7,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

combine4.c

@@ -7,7 +7,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

combine5.c

@@ -8,7 +8,7 @@
 #include   <stdio.h>
 #include   <stdlib.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

combine6.c

@@ -7,7 +7,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "../tthimage.h"
+#include   "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /* nouveau 28 fevrier 2014 / ave StExupery */

dither.c

@@ -5,7 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

dither2.c

@@ -5,7 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /* ya pas un probleme d'offset dans ces tables ? XXX */

dither3.c

@@ -5,7 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

dither4.c

@@ -5,7 +5,7 @@
 
 #include  <stdio.h>
 #include  <stdlib.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

effects.c

@@ -15,7 +15,7 @@
 #include  <string.h>
 #include  <math.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

effects2.c

@@ -12,7 +12,7 @@
 #include  <stdlib.h>
 #include  <math.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

effects3.c

@@ -13,7 +13,7 @@
 #include  <string.h>
 #include  <math.h>			/* yo ! */
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

eps.c

@@ -12,7 +12,7 @@
 
 #include  <stdio.h>
 #include  <time.h>
-#include  "../tthimage.h"
+#include  "tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*
@@ -33,7 +33,7 @@ if ( (fp=fopen(nom, "w")) == NULL )
 	}
 
 fputs("%!PS-Adobe-2.0 EPSF-1.2\n%%\n", fp);
-fprintf(fp, "%%%% Generator: libtthimage v %s\n", IMAGE_VERSION_STRING);
+fprintf(fp, "%%%% Generator: libimage v %s\n", IMAGE_VERSION_STRING);
 time(&temps);
 fprintf(fp, "%%%% Date: %s\n", ctime(&temps));
 fclose(fp);

essais.c

@@ -14,7 +14,7 @@
 #include  <math.h>
 #include  <string.h>
 
-#include  "../tthimage.h"
+#include  "tthimage.h"
 #include  "essais.h"
 
 /*::------------------------------------------------------------------::*/