diff --git a/Lib/Makefile b/Lib/Makefile index 624f005..4e13e6e 100644 --- a/Lib/Makefile +++ b/Lib/Makefile @@ -1,6 +1,6 @@ #----------------------------------------------------------------- # -# +# The infamous *LIBTTHIMAGE* 20 juin 2022 # #----------------------------------------------------------------- @@ -13,38 +13,112 @@ 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) -essais.o: essais.c $(DEPS) essais.h +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) -pht.o: pht.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 \ - drawing.o \ - essais.o \ - image.o imprime.o \ - marques.o msglib.o mustopen.o \ - pht.o \ - text0.o text1.o text16x24.o tga.o +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) $@ + $(RANLIB) $@ #----------------------------------------------------------------- @@ -56,7 +130,10 @@ t_t16x24: t_t16x24.c $(DEPS) $(STATICLIB) #----------------------------------------------------------------- -testtga: testtga.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 $@ #----------------------------------------------------------------- diff --git a/Lib/bitblt.c b/Lib/bitblt.c index 0883e97..be8ab40 100644 --- a/Lib/bitblt.c +++ b/Lib/bitblt.c @@ -12,7 +12,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/calculs.c b/Lib/calculs.c index 03975f8..ce1ff71 100644 --- a/Lib/calculs.c +++ b/Lib/calculs.c @@ -9,7 +9,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* pour les performances, cette fonction diff --git a/Lib/classif.c b/Lib/classif.c index 9904da0..001dc84 100644 --- a/Lib/classif.c +++ b/Lib/classif.c @@ -6,7 +6,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/col_reduc.c b/Lib/col_reduc.c index 69d0819..2b69589 100644 --- a/Lib/col_reduc.c +++ b/Lib/col_reduc.c @@ -6,7 +6,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/col_xyz.c b/Lib/col_xyz.c index d635cef..0ef05ef 100644 --- a/Lib/col_xyz.c +++ b/Lib/col_xyz.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/combine.c b/Lib/combine.c index 9512650..f4f8893 100644 --- a/Lib/combine.c +++ b/Lib/combine.c @@ -12,7 +12,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" #ifndef min #define min(a,b) ((a)<(b)?(a):(b)) diff --git a/Lib/combine2.c b/Lib/combine2.c index d7c5cff..fda8a05 100644 --- a/Lib/combine2.c +++ b/Lib/combine2.c @@ -8,7 +8,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/combine3.c b/Lib/combine3.c index 9337592..bfb77de 100644 --- a/Lib/combine3.c +++ b/Lib/combine3.c @@ -7,7 +7,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/combine4.c b/Lib/combine4.c index 9643d4b..0c47937 100644 --- a/Lib/combine4.c +++ b/Lib/combine4.c @@ -7,7 +7,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/combine5.c b/Lib/combine5.c index a5210df..1119356 100644 --- a/Lib/combine5.c +++ b/Lib/combine5.c @@ -8,7 +8,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/combine6.c b/Lib/combine6.c index e33dea3..a79bb83 100644 --- a/Lib/combine6.c +++ b/Lib/combine6.c @@ -7,7 +7,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* nouveau 28 fevrier 2014 / ave StExupery */ diff --git a/Lib/dither.c b/Lib/dither.c index 8932beb..99daa33 100644 --- a/Lib/dither.c +++ b/Lib/dither.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/dither2.c b/Lib/dither2.c index 2a37154..b29c1e7 100644 --- a/Lib/dither2.c +++ b/Lib/dither2.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* ya pas un probleme d'offset dans ces tables ? XXX */ diff --git a/Lib/dither3.c b/Lib/dither3.c index 21af15d..40fc257 100644 --- a/Lib/dither3.c +++ b/Lib/dither3.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/dither4.c b/Lib/dither4.c index a81dd50..ebfa8de 100644 --- a/Lib/dither4.c +++ b/Lib/dither4.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/doublesz.c b/Lib/doublesz.c new file mode 100644 index 0000000..643b0ba --- /dev/null +++ b/Lib/doublesz.c @@ -0,0 +1,154 @@ +/* + doublesz.c + ---------------- + see also: scale.c halfsize.c +*/ + +#include +#include +#include + +#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; xwidth; x++) + { + xx = x * 2; + for (y=0; yheight; 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; xwidth-1; x++) + { + xx = x * 2; + for (y=0; yheight-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; xwidth; x++) + { + for (y=0; yheight; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/effects.c b/Lib/effects.c index 8b078c5..2540425 100644 --- a/Lib/effects.c +++ b/Lib/effects.c @@ -15,7 +15,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/effects2.c b/Lib/effects2.c index eb98295..bc2efd7 100644 --- a/Lib/effects2.c +++ b/Lib/effects2.c @@ -12,7 +12,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/effects3.c b/Lib/effects3.c index 9d596a1..71f541c 100644 --- a/Lib/effects3.c +++ b/Lib/effects3.c @@ -13,7 +13,7 @@ #include #include /* yo ! */ -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/filtres.c b/Lib/filtres.c index d9a75bb..50af572 100644 --- a/Lib/filtres.c +++ b/Lib/filtres.c @@ -6,7 +6,7 @@ #include #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ void diff --git a/Lib/halfsize.c b/Lib/halfsize.c new file mode 100644 index 0000000..0094e14 --- /dev/null +++ b/Lib/halfsize.c @@ -0,0 +1,105 @@ + +/* + halfsize.c + ------------------ + + see also: scale.c doublesz.c + +*/ + +#include +#include +#include + +#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; yRpix[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 ! */ +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/luts15bits.c b/Lib/luts15bits.c index c56ff4a..1f7d564 100644 --- a/Lib/luts15bits.c +++ b/Lib/luts15bits.c @@ -12,7 +12,7 @@ #include #endif -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int Image_lut15_fill_0(int r[32768], int *g, int *b) diff --git a/Lib/op2x2.c b/Lib/op2x2.c index 6517f00..38ce690 100644 --- a/Lib/op2x2.c +++ b/Lib/op2x2.c @@ -6,7 +6,7 @@ #include #include /* pour abs() */ -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/operat.c b/Lib/operat.c index db5ce61..122ff0b 100644 --- a/Lib/operat.c +++ b/Lib/operat.c @@ -20,7 +20,7 @@ #include #endif -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/patterns.c b/Lib/patterns.c new file mode 100644 index 0000000..3be0bed --- /dev/null +++ b/Lib/patterns.c @@ -0,0 +1,175 @@ +/* + patterns.c + ------------------ +*/ + +#include +#include +#include +#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; xwidth; x++) + { + xx = (x * 256) / img->width; + for (y=0; yheight; 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; xwidth; x++) + for (y=0; yheight; 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; xwidth; x++) + { + x2 = (x * 256) / img->width; + for (y=0; yheight; 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; xwidth; x++) + { + x2 = (x * 256) / img->width; + for (y=0; yheight; 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; yheight; y++) + { + fy = (double)y; + for (x=0; xwidth; 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; xwidth; x++) + { + for (y=0; yheight; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/patterns2.c b/Lib/patterns2.c new file mode 100644 index 0000000..ad4dadb --- /dev/null +++ b/Lib/patterns2.c @@ -0,0 +1,121 @@ +/* + patterns2.c + ------------------ + various random patterns. + +*/ + +#include +#include + +#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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/patterns3.c b/Lib/patterns3.c new file mode 100644 index 0000000..eb36d0e --- /dev/null +++ b/Lib/patterns3.c @@ -0,0 +1,142 @@ +/* + patterns3.c + ------------------ + see also 'patterns.c' & 'patterns2.c' + +*/ + +#include +#include +#include +#include + +#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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + dx = (double)x / (double)dst->width; + for (y=0; yheight; 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; xwidth; x++) + { + fx = x % sx; + for (y=0; yheight; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/patterns4.c b/Lib/patterns4.c new file mode 100644 index 0000000..0c4a900 --- /dev/null +++ b/Lib/patterns4.c @@ -0,0 +1,233 @@ +/* + patterns4.c + ------------------ + some random noises + + see also 'patterns.c' & 'patterns2.c' + +*/ + +#include +#include + +#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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pixeliz.c b/Lib/pixeliz.c new file mode 100644 index 0000000..0523df8 --- /dev/null +++ b/Lib/pixeliz.c @@ -0,0 +1,84 @@ +/* + * pixeliz.c + * --------- + * + * nouveau 23 Juin 2003, je ne sais pas quoi mettre dedans... + * 14 mars 2007: je ne sais toujours pas... + * + */ + +#include +#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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pixels.c b/Lib/pixels.c new file mode 100644 index 0000000..9c994b5 --- /dev/null +++ b/Lib/pixels.c @@ -0,0 +1,38 @@ +/* + * PIXELS dot C + */ + +#include +#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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/plotteur.c b/Lib/plotteur.c new file mode 100644 index 0000000..80e0f7d --- /dev/null +++ b/Lib/plotteur.c @@ -0,0 +1,552 @@ +/* + plotteur.c + ---------- +*/ + +#include +#include +#include + +#ifdef NEED_ALLOCA_H +#include +#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>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; xnbre; x++) + { + for (y=0; yred[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>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; ynbre; y++) + { + for (x=0; xred[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; foonbre; 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; foonbre; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pov_hf15a.c b/Lib/pov_hf15a.c new file mode 100644 index 0000000..740dc81 --- /dev/null +++ b/Lib/pov_hf15a.c @@ -0,0 +1,438 @@ +/* + 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 +#include + +#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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight-1; y++) + { + for (x=1; xwidth-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; yheight-1; y++) + { + for (x=1; xwidth-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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; x++) + { + h = 32768 - Image_hf15_height(src, x, y); + Image_hf15_plot(dst, x, y, h); + } + } +return FUNC_IS_BETA; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pov_hf15b.c b/Lib/pov_hf15b.c new file mode 100644 index 0000000..8fc1299 --- /dev/null +++ b/Lib/pov_hf15b.c @@ -0,0 +1,134 @@ +/* + pov_hf15b.c + =========== + + for information about this file: + ask Thierry Boudet + +*/ + +#include +#include + +#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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pov_hf15c.c b/Lib/pov_hf15c.c new file mode 100644 index 0000000..860d256 --- /dev/null +++ b/Lib/pov_hf15c.c @@ -0,0 +1,263 @@ +/* + pov_hf15c.c + =========== + + Mixing operations beetween two height-fields. + --------------------------------------------- +*/ + +#include +#include +#include +#include + +#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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ +/*::------------------------------------------------------------------::*/ + diff --git a/Lib/pov_hf15d.c b/Lib/pov_hf15d.c new file mode 100644 index 0000000..7aa9c74 --- /dev/null +++ b/Lib/pov_hf15d.c @@ -0,0 +1,215 @@ +/* + pov_hf15d.c + =========== + bruitages de height-fields. + --------------------------- +*/ + +#include +#include + +#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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/pov_hf15e.c b/Lib/pov_hf15e.c new file mode 100644 index 0000000..b0f0a82 --- /dev/null +++ b/Lib/pov_hf15e.c @@ -0,0 +1,101 @@ +/* + pov_hf15e.c + =========== + + opérations de morphologie mathématique appliquées + aux height-fields. + +*/ + +#include +#include + +#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; yheight-1; y++) + { + for (x=1; xwidth-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; yheight-1; y++) + { + for (x=1; xwidth-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 + */ +/*::------------------------------------------------------------------::*/ + diff --git a/Lib/pov_hf15f.c b/Lib/pov_hf15f.c new file mode 100644 index 0000000..8157800 --- /dev/null +++ b/Lib/pov_hf15f.c @@ -0,0 +1,134 @@ +/* + pov_hf15f.c + =========== + traitement des bords des height-fields. + --------------------------------------- + new 3 octobre 2009 - avenue StExupery +*/ + +#include +#include + +#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; yheight; 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; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; yheight; y++) + { + for (x=0; xwidth; 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; +} +/*::------------------------------------------------------------------::*/ + diff --git a/Lib/pov_synth.c b/Lib/pov_synth.c new file mode 100644 index 0000000..d0a1e60 --- /dev/null +++ b/Lib/pov_synth.c @@ -0,0 +1,193 @@ +/* + pov_hf_synth.c + ============== + Thierry Boudet +*/ + +#include +#include +#include + +#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; yheight; y++) + { + for (x=0; xwidth; x++) + { + idx = -9999; + distmin = 99999999; + for (foo=0; foopoints[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 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; xwidth; x++) + { + dx = (double)x; + for (y=0; yheight; 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; xwidth; x++) + { + for (y=0; yheight; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/rgbmask.c b/Lib/rgbmask.c index b1bc8cd..a96a609 100644 --- a/Lib/rgbmask.c +++ b/Lib/rgbmask.c @@ -10,7 +10,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ /* diff --git a/Lib/scale.c b/Lib/scale.c new file mode 100644 index 0000000..e145bf7 --- /dev/null +++ b/Lib/scale.c @@ -0,0 +1,227 @@ + +/* + 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 +#include +#include + +#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; ydheight; yd++) + { + for (xd=0; xdwidth; 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; ydheight; yd++) + { + fyd = (double)yd; + fys = fyd / coefY; + for (xd=0; xdwidth; 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; +} +/*::------------------------------------------------------------------::*/ diff --git a/Lib/sobel4.c b/Lib/sobel4.c index e3faed6..a5b2c37 100644 --- a/Lib/sobel4.c +++ b/Lib/sobel4.c @@ -6,7 +6,7 @@ #include #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/tamppool.c b/Lib/tamppool.c index b87904f..8835636 100644 --- a/Lib/tamppool.c +++ b/Lib/tamppool.c @@ -5,7 +5,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ #define TAMPPOOL_VERSION "0.0.3" /*::------------------------------------------------------------------::*/ diff --git a/Lib/television.c b/Lib/television.c index 4c15e02..4b54d1e 100644 --- a/Lib/television.c +++ b/Lib/television.c @@ -6,7 +6,7 @@ #include #include -#include "tthimage.h" +#include "../tthimage.h" /*::------------------------------------------------------------------::*/ int diff --git a/Lib/vignetize.c b/Lib/vignetize.c index d6883dd..37f2073 100644 --- a/Lib/vignetize.c +++ b/Lib/vignetize.c @@ -5,7 +5,7 @@ */ #include -#include "tthimage.h" +#include "../tthimage.h" #undef DEBUG_LEVEL #define DEBUG_LEVEL 1 diff --git a/Lib/warp0.c b/Lib/warp0.c new file mode 100644 index 0000000..a2249f9 --- /dev/null +++ b/Lib/warp0.c @@ -0,0 +1,87 @@ +/* + warp0.c + --------------- + diverses deformations d'image. +*/ + +#include +#include + +#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; yheight; y++) + { + /* + printf("------- Ligne %d -----------------\n", y); + */ + arad = ((double)y / dheight) * M_PI; + + for (x=0; xwidth; 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 && ofxwidth && ofy>=0 && ofyheight ) + { + 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 + */ +/*::------------------------------------------------------------------::*/ diff --git a/Lib/warp1.c b/Lib/warp1.c new file mode 100644 index 0000000..8023d2f --- /dev/null +++ b/Lib/warp1.c @@ -0,0 +1,116 @@ +/* + warp1.c + _______________ +*/ + +#include +#include +#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; xdwidth; xd++) + { + fxd = (double)(xd-mx); + for (yd=0; ydheight; 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 && xswidth && ys>=0 && ysheight) + { + /* 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; xdwidth; xd++) + { + fxd = (double)(xd-mx); + for (yd=0; ydheight; 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 + */ +/*::------------------------------------------------------------------::*/ diff --git a/Lib/warp2.c b/Lib/warp2.c new file mode 100644 index 0000000..c0bc230 --- /dev/null +++ b/Lib/warp2.c @@ -0,0 +1,88 @@ +/* + warp2.c + --------------- +*/ + +#include +#include +#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; yheight; y++) + { + y2 = (y+oy) % src->height; + for (x=0; xwidth; 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 + */ +/*::------------------------------------------------------------------::*/ diff --git a/Lib/warp3.c b/Lib/warp3.c new file mode 100644 index 0000000..32db49e --- /dev/null +++ b/Lib/warp3.c @@ -0,0 +1,62 @@ +/* + warp3.c + --------------- +*/ + +#include +#include +#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 + */ +/*::------------------------------------------------------------------::*/ diff --git a/Tools/Makefile b/Tools/Makefile new file mode 100644 index 0000000..817b720 --- /dev/null +++ b/Tools/Makefile @@ -0,0 +1,24 @@ +#----------------------------------------------------------------- +# +# 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 $@ + + +#----------------------------------------------------------------- diff --git a/Tools/fonctions.c b/Tools/fonctions.c new file mode 100644 index 0000000..1baaed0 --- /dev/null +++ b/Tools/fonctions.c @@ -0,0 +1,430 @@ +/* + T G A _ O U T I L S + ------------------- + + fonctions communes a tous les outils - new 11 juin 2002 + +*/ + +#include +#include +#include + +/* 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 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 %ld\n", + __func__, ptr, seed); +#endif + srand(seed); + } + +return rand(); +} +/*::------------------------------------------------------------------::*/ diff --git a/Tools/tga_outils.h b/Tools/tga_outils.h new file mode 100644 index 0000000..7ce6520 --- /dev/null +++ b/Tools/tga_outils.h @@ -0,0 +1,102 @@ +/* + tga_outils.h + ------------ +*/ + +#include + +#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 + * ---------------------------------------------------- + */ + diff --git a/Tools/tga_tools.c b/Tools/tga_tools.c new file mode 100644 index 0000000..3953b71 --- /dev/null +++ b/Tools/tga_tools.c @@ -0,0 +1,402 @@ +/* + * TGA_TOOLS + */ + +#include +#include + +#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; +} +/*::------------------------------------------------------------------::*/ diff --git a/essais.h b/essais.h deleted file mode 100644 index ea9bf24..0000000 --- a/essais.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Routines de test de machins de la LibImage de tTh - * - * Bien entendu, pas la moindre explication ici :) - */ - -int Essai_Extractbits(char *fname, int k); -int Essai_des_Quadpics(char *fsrc, int k); -int Essai_des_drawings(char *fname, int k); -int Essai_des_Combines(char *fname, int k); -int Essai_de_la_Recursion(char *fname, int k); -int Essai_des_Glitches(char *fsrc, int k); -int Essai_anamorphoses(char *fsrc, double dk, int k); - -int Essai_des_bitplanes(char *txt, int w, int h); -int Essayer_les_alphas(char *fname, int k); -int Essai_des_bitplanes(char *txt, int w, int h); - -int Manipuler_les_couleurs(char *fname, int k); -int Essai_luminance(char *scrname, int k); -int Essais_plot_Map(int k); -int Essai_raw16bits(char *srcname, int k); -int Essai_color_2_map(char *srcname, int k); -int Essai_des_gray_ops(char *srcname, int k); -int Essai_des_Contrastes(char *, int); -int Essai_des_lut15bits(char *srcname, int k); -int Essai_des_mires(char *, int, int); -int Essai_des_zooms(char *srcname, int k); - -int Essai_des_7_segments(char *srcname, int flag); -int Essai_des_distances(char *srcname, int nbre, int flag); -int Essai_des_cadres(char *srcname, int flags); -int Filtre_Directionnel(char *srcname, int flags); - -int Test_des_trucs_2x2(char *srcname, int k); -int Test_des_warpings(char *srcname, int k); -int Test_des_mosaiques(char *srcname, int k); - -int Test_hf15_synth_fromfunc(char *fname); -int Test_hf15_synth_fromPtl(char *fname, char *oname); -int Test_funcs_hf15(char *mntname, int flag); -int Test_des_df3(char *txt, int k); - -int Test_vignettes(char *srcname, int k); - -int Test_classif(char *srcname, int k); -int Test_rgbmask(char *srcname); -void Test_rgb2xyz(void); - -int Essai_des_marquages(char *srcname, int nombre, char *texte); -void Test_double_size(void); -int Test_new_scale(char *fnamesrc, int coef); - -int Test_copie_de_rectangles(char *nomsource); -int Test_Egalisations(char *nomsource, int k); -int Test_Dithering(char *nomsource, int k); -int Test_des_marquages(char *srname, int k1, int k2); -int Test_Effects_A(char *nomsource, int flag); - -int Test_des_tamppools(char *imgname, int param); -int Essai_export_palettes(char *basename); - -int Test_des_filtres(char *srcname, int k); - -void Test_des_patterns(char *prefix, int foo, int bar); -int Test_des_pixeliz(char *srcname, int flags); - -int Essai_des_bitblt(char *srcname, int k); -int Essai_des_gadgrect(char *srcname, int k); - -int Essai_Television(char *source, int k); - -/* dans essais2;c */ -int Essai_des_big_chars(char *fname, int k); -int Essai_des_jauges(char *fname, int k); - - -/* - * Le programme principal est 'testtga.c' mais il serait bien de faire - * une fonction qui enchaine tous les Tests et tous les Essais afin - * de pouvoir facilement valgrinder le tout :) - */ -