tTh/libtthimage
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
9644b43b11
libtthimage/Lib/essais.c

1419 lines
38 KiB
C
Raw Normal View History

second massive import batch
2022-06-26 20:06:35 +11:00
/*
ce fichier contient diverses fonctions pour tester
les trucs et puis les machins.
en general, c'est des fonctions que je met ici et
elles sont appelees par le main dans 'testtga.c'.
NOTE: il faudrait verifier si les liberations de
memoire sont bien faites...
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
moving files around...
2022-06-27 07:55:56 +11:00
#include "../tthimage.h"
second massive import batch
2022-06-26 20:06:35 +11:00
#include "essais.h"
/*::------------------------------------------------------------------::*/
/* nouveau vacances de fevrier 2010 */
int Essayer_les_alphas(char *fname, int k)
{
Image_Desc *src, *dst;
int foo;
printf("=========== %s ( '%s' %d ) ===============\n",
__func__, fname, k);
if (NULL==(src=Image_TGA_alloc_load(fname))) {
fprintf(stderr, "%s : omg, '%s' is not readable.\n", __func__, fname);
exit(1);
}
if (NULL==(dst=Image_clone(src, 0))) {
fprintf(stderr, "%s : omg, %p is not clonable.\n", __func__, src);
exit(5);
}
foo = Image_tampon_alpha_0(src, NULL, dst);
if (foo) Image_print_error(__func__, foo);
Image_TGA_save("Pictures/aaaa-tampon.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
Image_DeAllocate(src); free(src);
return 42;
}
/*::------------------------------------------------------------------::*/
int Manipuler_les_couleurs(char *fname, int k)
{
Image_Desc *src, *dst;
int foo;
printf("=========== %s ( '%s' %d ) ===============\n",
__func__, fname, k);
if (NULL==(src=Image_TGA_alloc_load(fname))) {
fprintf(stderr, "%s : omg, '%s' is not readable.\n", __func__, fname);
exit(1);
}
if (NULL==(dst=Image_clone(src, 0))) {
fprintf(stderr, "%s : omg, %p is not clonable.\n", __func__, src);
exit(5);
}
/* OK, les deux images doivent etre en place */
fprintf(stderr, "trying %p -> %p\n", src, dst);
foo = Image_BiColor_0(src, dst, 0);
Image_print_error("BiColor 0", foo);
foo = Image_BiColor_1(src, dst, 0, 1);
Image_print_error("BiColor 1", foo);
return WTF_OSEF;
}
/*::------------------------------------------------------------------::*/
int Essai_luminance(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo;
fprintf(stderr, "=========== %s ( %s %d )\n", __func__, srcname, k);
if (NULL==(src=Image_TGA_alloc_load(srcname))) {
fprintf(stderr, "%s : oups, '%s' n'est pas lisible\n",
__func__, srcname);
exit(1);
}
/* on va creer le receptacle des horreurs */
if (NULL==(dst=Image_clone(src, 0))) {
exit(5);
}
/* que doit valoir le troisieme parametre ? */
foo = Image_luminance(src, dst, -50);
Image_TGA_save("Pictures/aaaa-luminance--50.tga", dst, 0);
foo = Image_luminance(src, dst, 128);
Image_TGA_save("Pictures/aaaa-luminance-128.tga", dst, 0);
foo = Image_luminance(src, dst, 200);
Image_TGA_save("Pictures/aaaa-luminance-200.tga", dst, 0);
foo = Image_luminance(src, dst, 500);
if (foo) Image_print_error(__func__, foo);
Image_TGA_save("Pictures/aaaa-luminance-500.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
Image_DeAllocate(src); free(src);
return 0;
}
/*::------------------------------------------------------------------::*/
int Essais_plot_Map(int k)
{
RGB_map map;
int foo;
printf("=========== %s ( %d ) ===============\n",
__func__, k);
foo = Image_load_color_Map("volcano.map", "Volcano Map", &map);
Image_print_error("chargement Volcano", foo);
foo = Image_plot_square_Map("Pictures/aaaa-sqrmap-volcano.tga", &map, "yo le monde", 0);
Image_print_error("plot square Map", foo);
foo = Image_load_color_Map("neon.map", "Neon Map", &map);
Image_print_error("chargement Neon", foo);
foo = Image_plot_square_Map("Pictures/aaaa-sqrmap-neon.tga", &map, "yo le monde", 0);
Image_print_error("plot square Map", foo);
foo = Image_load_color_Map("primaires.map", "Primaire Map", &map);
Image_print_error("chargement Primaire", foo);
foo = Image_plot_square_Map("Pictures/aaaa-sqrmap-primaires.tga", &map, "yo !", 0);
Image_print_error("plot square Map", foo);
foo = Image_load_color_Map("reduce.map", "reduce Map", &map);
Image_print_error("chargement reduce", foo);
foo = Image_plot_square_Map("Pictures/aaaa-sqrmap-reduce.tga", &map, "yo !", 0);
Image_print_error("plot square Map", foo);
return 0;
}
/*::------------------------------------------------------------------::*/
/*
* raw16bits.c - new 22 septembre 2009 - Petit London
*/
int Essai_raw16bits(char *srcname, int k)
{
printf("=========== %s ( '%s' %d ) ===============\n",
__func__, srcname, k);
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
/* new 21 septembre 2009 - essai des reductions chromatiques */
int Essai_color_2_map(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo, idx;
char fname[200];
printf("============== %s ( '%s' %d ) ==================\n",
__func__, srcname, k);
if (NULL==(src=Image_TGA_alloc_load(srcname))) {
fprintf(stderr, "%s : oups, '%s' n'est pas lisible\n",
__func__, srcname);
exit(1);
}
/* on va creer le receptacle des horreurs */
if (NULL==(dst=Image_clone(src, 0))) {
exit(5);
}
/* ah bravo ! enfin un test unitaire appelable
* depuis le test unitaire */
for (idx=0; idx<20; idx++)
{
foo = Image_essai_col_reduce(src, dst, 133, idx);
printf("le retour de l'essai_col_reduce %d est %d\n", idx, foo);
if (OLL_KORRECT==foo)
{
sprintf(fname, "Pictures/aaaa-colredux-%02d.tga", idx);
Image_TGA_save(fname, dst, 0);
}
}
Image_DeAllocate(dst); free(dst);
Image_DeAllocate(src); free(src);
return 666;
}
/*::------------------------------------------------------------------::*/
/* nouveau 8 septembre 2009 - essai des operations etranges sur le gris */
int Essai_des_gray_ops(char *srcname, int k)
{
printf("================= %s ( '%s' %d ) =============\n",
__func__, srcname, k);
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
/* nouveau 1 septembre 2009 - ave StExupery */
int Essai_des_mires(char *texte, int ka, int kb)
{
Image_Desc *img, *tmp;
int foo;
printf("================ %s ( '%s' %d %d ) ==============\n",
__func__, texte, ka, kb);
if (NULL==(img=Image_alloc(800, 480, IMAGE_RGB))) {
fprintf(stderr, "%s : FAIL no memory\n", __func__);
abort();
}
foo = Image_mircol_2(img, texte, 0);
Image_print_error("mircol 2", foo);
Image_TGA_save("Pictures/aaaa-mircol-2.tga", img, 0);
tmp = Image_clone(img, 0);
Image_decompose(img, tmp, 0);
Image_TGA_save("Pictures/aaaa-mircol-2-dec.tga", tmp, 0);
Image_DeAllocate(tmp); free(tmp);
printf("%s -> mircol_3 0\n", __func__);
foo = Image_mircol_3(img, texte, 0);
Image_print_error("mircol 3 0", foo);
Image_TGA_save("Pictures/aaaa-mircol-3-0.tga", img, 0);
printf("%s -> mircol_3 0\n", __func__);
foo = Image_mircol_3(img, texte, 1);
Image_print_error("mircol 3 1", foo);
Image_TGA_save("Pictures/aaaa-mircol-3-1.tga", img, 0);
printf("%s -> mircol_3 2\n", __func__);
foo = Image_mircol_3(img, texte, 2);
Image_print_error("mircol 3 2", foo);
Image_TGA_save("Pictures/aaaa-mircol-3-2.tga", img, 0);
return -1;
}
/*::------------------------------------------------------------------::*/
int Essai_des_lut15bits(char *srcname, int k)
{
int foo;
printf("================= %s ( '%s' %d ) =============\n",
__func__, srcname, k);
foo = Image_lut15_essai(srcname, "aaaa-hf15-lut-0.tga", 0);
Image_print_error("lut 15, 0 = ", foo);
foo = Image_lut15_essai(srcname, "aaaa-hf15-lut-1.tga", 1);
Image_print_error("lut 15, 1 = ", foo);
return 42;
}
/*::------------------------------------------------------------------::*/
/* nouveau - 8 novembre 2009 */
int Essai_des_bitblt(char *srcname, int k)
{
Image_Desc *src, *dst;
Image_Rect rectA, rectB;
printf("================= %s ( '%s' %d ) =============\n",
__func__, srcname, k);
if ( NULL == (src=Image_TGA_alloc_load(srcname)) ) {
fprintf(stderr, "%s : *PAN* sur %s (not found ?)\n", __func__, srcname);
exit(1);
}
fprintf(stderr, "source %dx%d\n", src->width, src->height);
dst = Image_clone(src, 0);
rectA.w = src->width;
rectA.h = src->height;
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
int Essai_des_gadgrect(char *srcname, int k)
{
/* ce truc est nouveau, du 4 fevrier 2009 */
Image_Desc *image;
Image_Rect coin;
int foo;
printf("================= %s ( '%s' %d ) =============\n",
__func__, srcname, k);
if ( NULL == (image=Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "%s : Bang sur %s (not found ?)\n", __func__, srcname);
exit(1);
}
coin.x = image->width / 3; coin.y = image->height / 3;
coin.w = image->width / 5; coin.h = image->height / 7;
Image_dump_rect(&coin, "le coin(pan)", 0);
foo = Image_gadrct_Hsweep_0(image, &coin, 0);
Image_TGA_save("Pictures/aaaa-Hsweep0.tga", image, 0);
Image_calc_plot_histo(image, "Pictures/aaaa-lol-mdr.tga");
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
int Essai_des_zooms(char *srcname, int k)
{
Image_Desc *origine, *nucked;
int foo;
printf("================= %s ( '%s' %d ) =============\n",
__func__, srcname, k);
if ( NULL == (origine=Image_TGA_alloc_load(srcname)) ) {
fprintf(stderr, "%s : pas de '%s' ici\n", __func__, srcname);
exit(1);
}
if ( NULL == (nucked=Image_clone(origine, 1)) ) {
fprintf(stderr, "%s : FailClone of %p\n", __func__, origine);
exit(1);
}
foo = Image_essai_zoom(origine, nucked, 1.18, 0.42, 0);
Image_TGA_save("Pictures/aaaa-zoom.tga", nucked, 0);
Image_DeAllocate(nucked); free(nucked);
Image_DeAllocate(origine); free(origine);
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
int Essai_des_distances(char *srcname, int nbre, int flag)
{
Image_Desc *src, *dst;
int foo;
double dr, dg, db;
printf("============ %s ( '%s' %d %d ) ============\n", __func__,
srcname, nbre, flag);
if ( NULL == (src=Image_TGA_alloc_load(srcname)) ) {
fprintf(stderr, "%s : Bang sur %s\n", __func__, srcname);
exit(1);
}
#if DEBUG_LEVEL
fprintf(stderr, "%s : img @ %p\n", __func__, src);
#endif
if ( NULL == (dst=Image_clone(src, 1)) ) {
fprintf(stderr, "%s : FailClone of %p\n", __func__, src);
exit(1);
}
dr = dg = db = 0.0;
for (foo=0; foo<nbre; foo++)
{
foo = Image_distance_0(src, dst, &dr, &dg, &db);
printf("%5d : %g %g %g\n", foo, dr, dg, db);
}
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
int Essai_des_7_segments(char *srcname, int flag)
{
Image_Desc *origine, *imgtmp;
int foo;
char buffer[100];
printf("=========== essai 7 segments sur %s =========\n", srcname);
if ( NULL == (origine=Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "7seg : Bang sur %s\n", srcname);
exit(1);
}
printf("image originale @ %p\n", origine);
if (flag & 1)
{
imgtmp = Image_clone(origine, 1);
foo = Image_7_segments(imgtmp, 9, 0);
printf("%s : image 7 segments -> %d\n", __FILE__, foo);
Image_TGA_save("Pictures/aaaa-7seg.tga", imgtmp, 0);
Image_DeAllocate(imgtmp); free(imgtmp);
}
if (flag & 2)
{
imgtmp = Image_clone(origine, 1);
sprintf(buffer, "%04d", 42);
foo = Image_7seg_tag0(imgtmp, buffer, 0);
printf("%s : image 7 seg tag0 -> %d\n", __FILE__, foo);
Image_TGA_save("Pictures/aaaa-7seg-tag0.tga", imgtmp, 0);
Image_DeAllocate(imgtmp); free(imgtmp);
}
Image_DeAllocate(origine); free(origine);
printf("fin essai 7 segs\n");
return 7;
}
/*::------------------------------------------------------------------::*/
/* les essais de cadres sont partis dans essais2.c */
/*::------------------------------------------------------------------::*/
int Filtre_Directionnel(char *srcname, int flags)
{
int rotule, foo;
Image_Desc *origine, *imgtmp;
char chaine[100];
int filtre[11];
int w3, h3;
Image_Rect rect;
static int datas_sobel[] =
{
1, 2, 1,
0, 0, 0,
-1, -2, -1,
1, 128
};
static int datas_prewitt[] =
{
1, 1, 1,
0, 0, 0,
-1, -1, -1,
1, 128
};
static struct offxy
{ int x, y; } offsets[] = {
{ 1, 0 },
{ 2, 0 },
{ 2, 1 },
{ 2, 2 },
{ 1, 2 },
{ 0, 2 },
{ 0, 1 },
{ 0, 0 }
};
printf("========= Filtrage directionnel sur %s =======\n", srcname);
if ( NULL == (origine=Image_TGA_alloc_load(srcname)) ) {
fprintf(stderr, "%s : Bang sur %s\n", __func__, srcname);
exit(1);
}
printf("image originale @ %p\n", origine);
imgtmp = Image_clone(origine, 1);
w3 = origine->width * 3;
h3 = origine->height * 3;
if (flags) memcpy(filtre, datas_prewitt, sizeof(filtre));
else memcpy(filtre, datas_sobel, sizeof(filtre));
for (rotule=0; rotule<8; rotule++)
{
foo = Image_convolueur_2(origine, imgtmp, filtre, "rgb");
printf("=== Passe %d retour %d\n", rotule, foo);
Image_raz_sides(imgtmp);
sprintf(chaine, "Pictures/aaaa_fildir_%x.tga", rotule);
Image_TGA_save(chaine, imgtmp, 0);
/* de la scorie ?
rect.x = offsets[rotule].x * origine->width;
rect.y = offsets[rotule].y * origine->height;
Image_dump_rect(&rect, "filtre direct", 0);
*/
Image_rotate_filtre(filtre);
}
return FULL_NUCKED;
}
/*::------------------------------------------------------------------::*/
/* nouveau 31 aout 2008 - ave St Exupery */
int Test_des_trucs_2x2(char *srcname, int k)
{
int foo;
Image_Desc *origine, *imgtmp;
printf("===== LES TRUCS 2 x 2 ===[ %s ]=[ %d ]=====\n", srcname, k);
if ( NULL == (origine=Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "%s : Bang sur %s\n", __func__, srcname);
exit(1);
}
printf("image originale @ %p\n", origine);
imgtmp = Image_clone(origine, 1);
if (NULL == imgtmp) {
fprintf(stderr, "fail in %s - %s\n", __func__, __FILE__);
abort();
}
foo = Image_2x2_contours_0(imgtmp);
Image_TGA_save("Pictures/aaaa-2x2-a.tga", imgtmp, 0);
Image_seuil_RGB(origine, imgtmp, 64, 128, 192);
foo = Image_2x2_contours_0(imgtmp);
Image_TGA_save("Pictures/aaaa-2x2-b.tga", imgtmp, 0);
Image_AutoSeuilRGB(origine, imgtmp);
foo = Image_2x2_contours_0(imgtmp);
Image_TGA_save("Pictures/aaaa-2x2-c.tga", imgtmp, 0);
Image_DeAllocate(imgtmp); free(imgtmp);
Image_DeAllocate(origine); free(origine);
return 42;
}
/*::------------------------------------------------------------------::*/
/* new 14 septembre 2008 /o\ 51 ans... */
int Test_des_warpings(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo, ax, ay;
printf("====== essais Warping sur %s (k=%d) ====\n", srcname, k);
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "Err loading '%s'\n", srcname);
exit(5);
}
dst = Image_clone(src, 0);
foo = Image_warp_essai_0(src, dst, 33.5, 100, 100);
Image_TGA_save("Pictures/warp-essai-0.tga", dst, 0);
foo = Image_center_rotate(src, dst, 21.5);
Image_TGA_save("Pictures/warp-center-rotate.tga", dst, 0);
ax = (src->width * 2) / 3;
ay = (src->height * 2) / 3;
foo = Image_shift_xy(src, dst, ax, ay);
Image_TGA_save("Pictures/warp-shift-xy.tga", dst, 0);
foo = Image_shift_x(src, dst, ax);
Image_TGA_save("Pictures/warp-shift-x.tga", dst, 0);
foo = Image_shift_y(src, dst, ay);
Image_TGA_save("Pictures/warp-shift-y.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return 42;
}
/*::------------------------------------------------------------------::*/
/* new 7 avril 2007, essai des mosaiques */
int Test_des_mosaiques(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo;
fprintf(stderr, "============== %s : k %d ======\n", __func__, k);
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "%s : Err loading '%s'\n", __func__, srcname);
exit(5);
}
dst = Image_clone(src, 0);
foo = Image_mosaic_0(src, dst, 6, 6, 0);
Image_TGA_save("Pictures/aaaa-mosaic-0.tga", dst, 0);
foo = Image_mosaic_simple(src, dst);
Image_TGA_save("Pictures/aaaa-mosaic-s.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return 42;
}
/* quelque part, il doit aussi y avoir un test des grilles */
/*::------------------------------------------------------------------::*/
/* new 11 decembre 2007 - ave St Exupery */
static double fonction(int x, int y, int param)
{
double value;
if (param)
value = 0.333333 + sin((double)x) + cos((double)y);
else
value = 0.333333 + sin((double)x) * cos((double)y);
return value;
}
int Test_hf15_synth_fromfunc(char *fname)
{
Image_Desc *image;
int foo;
#if DEBUG_LEVEL
fprintf(stderr, "in %s, param '%s' not used ?\n", __func__, fname);
#endif
image = Image_alloc(256, 256, 3);
foo = Image_hf15_synth_fromfunc0(image, 33, fonction);
fprintf(stderr, "Synth from func %d\n", foo);
Image_TGA_save("Pictures/aaaa-synthfunc.tga", image, 0);
return 0;
}
/*::------------------------------------------------------------------::*/
int Test_hf15_synth_fromPtl(char *iname, char *oname)
{
Image_Desc *src, *dst;
Image_PtList *ptl;
Image_Rect boite;
int x, y, h, foo;
int r, g, b;
printf("======= Synth from PointList ===========\n");
if (NULL == (src = Image_TGA_alloc_load(iname)) )
{
fprintf(stderr, "%s: Err loading '%s'\n", __func__, iname);
exit(5);
}
dst = Image_clone(src, 0);
ptl = Image_ptl_alloc(300, "pix2ptl");
printf("point list @ %p\n", ptl);
for (foo=0; foo<6000; foo++)
{
x = rand() % (src->width - 5);
y = rand() % (src->height - 5);
Image_getRGB(src, x, y, &r, &g, &b);
h = r + g + b;
Image_ptl_add(ptl, x, y, h, 0);
}
Image_ptl_dump(ptl, "apres randomz");
memset(&boite, 0, sizeof(Image_Rect));
foo = Image_ptl_boundingbox(ptl, &boite);
Image_print_error("ptl bounding box", foo);
Image_dump_rect(&boite, "ptl bounding box", 1);
foo = Image_hf15_synth_1(dst, ptl);
Image_TGA_save("Pictures/aaaa-synthptl.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
Image_ptl_kill(ptl, __func__);
return 0;
}
/*::------------------------------------------------------------------::*/
int Test_funcs_hf15(char *srcname, int flag)
{
Image_Desc *src, *dst;
int foo;
int minimum, maximum;
fprintf(stderr, "entering ================>> %s\n", __func__);
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "Error loading '%s'\n", srcname);
exit(5);
}
if (flag)
{
fprintf(stderr, "mmmm flag is %02x, need some debug...\n", flag);
}
fprintf(stderr, "picture '%s' : %d x %d\n", srcname, src->width, src->height);
foo = Image_hf15_rgb2hf(src, src, 0);
printf("rgb2hf -> %d\n", foo);
Image_hf15_save_PGM("Pictures/aaaa-hf15-src.pgm", src, "from 'essais.c'");
dst = Image_clone(src, 0);
Image_TGA_save("Pictures/aaaa-clone-hf15.tga", dst, 0);
foo = Image_plot_histo_hf15(src, "aaaa-histo-src.tga", "from essais.c", 0, 0);
fprintf(stderr, "retour plottage de l'histo = %d\n", foo);
foo = Image_hf15_sqrt(src, dst);
foo = Image_plot_histo_hf15(dst, "aaaa-histo-sqrt.tga", "from essais.c", 0, 0);
Image_hf15_save_PGM("Pictures/aaaa-hf15-sqrt.pgm", src, "from 'essais.c'");
fprintf(stderr, "Ok, done %d sqrt\n", foo);
Image_copy(src, dst);
foo = Image_hf15_noise_2(dst, 42, 5, 0, 0);
Image_TGA_save("Pictures/aaaa-hf15-noise2.tga", dst, 0);
Image_copy(src, dst);
foo = Image_hf15_noise_3(dst, 42.42, 0);
Image_TGA_save("Pictures/aaaa-hf15-noise3.tga", dst, 0);
Image_copy(src, dst);
foo = Image_hf15_rgb2hf(dst, dst, 0);
/* calculer le min et le max AVANT */
Image_hf15_calc_minmax(dst, "Avant le sweep", &minimum, &maximum);
foo = Image_hf15_sweep(dst, 42, 400, 0);
/* calculer le min et le max APRES */
Image_hf15_calc_minmax(dst, "Apres le sweep", &minimum, &maximum);
Image_TGA_save("Pictures/aaaa-hf15-sweep-c.tga", dst, 0);
Image_hf15_save_PGM("Pictures/aaaa-hf15-sweep-c.pgm", dst, "from essais.c");
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return IMAGE_FAIL;
}
/*::------------------------------------------------------------------::*/
int Test_vignettes(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo;
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "Err loading '%s'\n", srcname);
exit(5);
}
dst = Image_clone(src, 0);
foo = Image_vignetize_x_0(src, dst, k);
Image_print_error("vignetize_x_0", foo);
Image_TGA_save("Pictures/aaaa-vignetize_x0.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return 42;
}
/*::------------------------------------------------------------------::*/
int Test_classif(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo;
fprintf(stderr, "============= %s sur %s =======\n", __func__, srcname);
#define DC 50
static Une_Classe_Sph classs[] =
{
{ 127, 127, 127, DC, 127, 127, 127 },
{ 255, 255, 255, DC, 255, 255, 255 },
{ 255, 0, 0, DC, 255, 0, 0 },
{ 0, 0, 255, DC, 0, 0, 255 },
{ 0, 255, 0, DC, 0, 255, 0 }
};
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "Err loading '%s'\n", srcname);
exit(5);
}
dst = Image_clone(src, 0);
foo = Image_classif_0(src, dst);
Image_print_error("essai classif 0", foo);
Image_TGA_save("Pictures/aaaa-classif0.tga", dst, 0);
foo = Image_classif_1(src, dst, classs, 5, 0);
Image_print_error("essai classif 1", foo);
Image_TGA_save("Pictures/aaaa-classif1.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return 42;
}
/*::------------------------------------------------------------------::*/
/* new 24 avril 2007, essais sur le module rgbmask.c */
int
Test_rgbmask(char *srcname)
{
Image_Desc *source, *image ;
int foo;
source = Image_TGA_alloc_load(srcname);
image = Image_clone(source, 0);
foo = Image_rgbmask_H(source, image, 0);
Image_TGA_save("Pictures/aaaa-rgbmaskH.tga", image, 0);
foo = Image_rgbmask_V(source, image, 0);
Image_TGA_save("Pictures/aaaa-rgbmaskV.tga", image, 0);
foo = Image_rgbmask_2(source, image, 0);
Image_TGA_save("Pictures/aaaa-rgbmask2.tga", image, 0);
foo = Image_rgbmask_R(source, image, 0);
Image_TGA_save("Pictures/aaaa-rgbmaskR.tga", image, 0);
return 42;
}
/*::------------------------------------------------------------------::*/
/* new 9 avr 2007, tests du module col_xyz.c */
void Test_rgb2xyz(void)
{
int r, g, b, foo;
double dx, dy, dz;
double minx, maxx, miny, maxy, minz, maxz;
minx = miny = minz = 999999.9;
maxx = maxy = maxz = -999999.9;
for (r=0; r<256; r+=1)
{
for (g=0; g<256; g+=1)
{
for (b=0; b<256; b+=1)
{
foo = Image_pix_rgb2xyz_d(r, g, b, &dx, &dy, &dz);
if (dx > maxx) maxx = dx;
if (dx < minx) minx = dx;
if (dy > maxy) maxy = dy;
if (dy < miny) miny = dy;
if (dz > maxz) maxz = dz;
if (dz < minz) minz = dz;
}
}
}
fprintf(stderr, "fin test rgb2xyz\n");
fprintf(stderr, "%12.6f X %12.6f\n", minx, maxx);
fprintf(stderr, "%12.6f Y %12.6f\n", miny, maxy);
fprintf(stderr, "%12.6f Z %12.6f\n", minz, maxz);
}
/*::------------------------------------------------------------------::*/
/* added 24 mai 2009, because I need a reliable timestamp utility for
* my big POV project, "Parking Maudit".
*/
int Essai_des_marquages(char *srcname, int nombre, char *texte)
{
Image_Desc *src, *dst;
int foo;
if (NULL == (src = Image_TGA_alloc_load(srcname)) )
{
fprintf(stderr, "Err in %s when loading '%s'\n", __func__, srcname);
exit(5);
}
printf("le nombre est %d\n", nombre);
dst = Image_clone(src, 1);
fprintf(stderr, ">>>> %s : src (%s) %p dst %p\n", __func__, srcname, src, dst);
foo = Image_marque_timestamp(dst, texte, NULL, 0);
Image_TGA_save("Pictures/aaaa-timestamp-0.tga", dst, 0);
Image_copy(src, dst);
foo = Image_marque_timestamp(dst, texte, NULL, 1);
Image_TGA_save("Pictures/aaaa-timestamp-1.tga", dst, 0);
return 42;
}
/*::------------------------------------------------------------------::*/
void Test_double_size(void)
{
Image_Desc *src, *dst;
src = Image_alloc(50, 50, 3);
Image_clear(src, 0, 0, 0);
Image_marque_0(src, 128);
Image_plotRGB(src, 11, 2, 255, 255, 255);
Image_plotRGB(src, 12, 2, 255, 255, 255);
Image_plotRGB(src, 13, 2, 255, 255, 255);
dst = Image_MakeDoubleSize(src, 1);
Image_TGA_save("Pictures/aaaa_dblsz.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
dst = Image_MakeDoubleSize_H(src, 0);
Image_TGA_save("Pictures/aaaa_dblszh0.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
dst = Image_MakeDoubleSize_H(src, 1);
Image_TGA_save("Pictures/aaaa_dblszh1.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
Image_DeAllocate(src); free(src);
}
/*::------------------------------------------------------------------::*/
/* new, around Hallowen 2009 */
int Test_new_scale(char *fnamesrc, int k)
{
Image_Desc *src, *dst;
int foo;
#define WDST 512
#define HDST 512
fprintf(stderr, "============= %s ( '%s' ) ================\n",
__func__, fnamesrc);
src = Image_TGA_alloc_load(fnamesrc);
if (NULL == src)
{
fprintf(stderr, "? %s non existantz ?\n", fnamesrc);
abort();
}
Image_marque_0(src, 255);
Image_TGA_save("Pictures/aaaa_new_scale_0.tga", src, 0);
dst = Image_alloc(WDST, HDST, 3);
foo = Image_scale_bilinear(src, dst, 0);
printf("retour scale bilinear -> %d\n", foo);
foo = Image_TGA_save("Pictures/aaaa_new_scale_bilin.tga", dst, 0);
#if DEBUG_LEVEL
fprintf(stderr, "saving in %s -> %d\n", __func__, foo);
#endif
Image_DeAllocate(dst); free(dst);
dst = Image_alloc(WDST, HDST, 3);
foo = Image_scale_simple(src, dst, 0);
printf("retour scale simple -> %d\n", foo);
Image_TGA_save("Pictures/aaaa_new_scale_simple.tga", dst, 0);
Image_DeAllocate(dst); free(dst);
Image_DeAllocate(src); free(src);
return 0;
}
/*::------------------------------------------------------------------::*/
/*
*/
int
Test_copie_de_rectangles(char *nomsource)
{
Image_Desc *source, *image, *finale;
int foo, w, h, x, y;
Image_Rect rect;
char *cptr;
printf("======= test des copies de rectangles ========\n");
source = Image_TGA_alloc_load(nomsource);
if (NULL==source) {
fprintf(stderr, "fail on '%s'\n", nomsource);
return -1;
}
printf("'%s' loaded : %dx%d\n", nomsource, source->width, source->height);
cptr = "wou.tga";
image = Image_TGA_alloc_load(cptr);
if (NULL==image) {
fprintf(stderr, "fail on '%s'\n", cptr);
Image_DeAllocate(source); free(source);
return -1;
}
finale = Image_clone(source, 1);
rect.x = 50; rect.y = 50;
rect.h = 100; rect.w = 160;
foo = Image_copy_rect(image, &rect, finale, 10, 10);
Image_print_error("Image copy rect", foo);
Image_TGA_save("Pictures/aaaa_copyrect.tga", finale, 0);
Image_DeAllocate(image); free(image);
/* essai de la fonction 'Image_overlay' */
w = source->width / 4;
h = source->height / 4;
image = Image_alloc(w, h, 3);
Image_pattern_000(image, 0x55);
Image_copy(source, finale);
/* orly bad code here */
for (x=-w; x<=w; x+=w)
{
for (y=-h; y<=h; y+=h)
{
fprintf(stderr, " *** overlaying to %d, %d\n", x, y);
foo = Image_overlay(source, finale, x, 10);
Image_print_error("Image overlay", foo);
}
}
Image_TGA_save("Pictures/aaaa_overlay.tga", finale, 0);
Image_copy(source, finale);
foo = Image_overlay_mix(source, finale, 30, 40, 5000);
Image_TGA_save("Pictures/aaaa_overlay_mix.tga", finale, 0);
Image_DeAllocate(image); free(image);
Image_DeAllocate(source); free(source);
Image_DeAllocate(finale); free(finale);
return 0;
}
/*::------------------------------------------------------------------::*/
int
Test_Egalisations(char *nomsource, int k)
{
Image_Desc *image, *deuxieme, *troisieme;
int x, y;
fprintf(stderr, "============= Egalisations %s %d =====\n", nomsource, k);
image= Image_TGA_alloc_load(nomsource);
printf("image loaded %p\n", image);
deuxieme = Image_clone(image, 0);
printf("image 2 cloned %p\n", deuxieme);
Image_egalise_mono_0(image, deuxieme, 0);
troisieme = Image_clone(image, 0);
printf("image 3 cloned %p\n", troisieme);
Image_egalise_RGB(image, troisieme, 0);
for (x=0; x<image->width; x++)
{
if (x < image->width/3)
{
for (y=0; y<image->height; y++)
Image_pixel_copy(image, x, y, troisieme, x, y);
}
else
if (x > image->width/3*2)
{
for (y=0; y<image->height; y++)
Image_pixel_copy(deuxieme, x, y, troisieme, x, y);
}
#if DEBUG_LEVEL > 2
printf("%4d\r", x); fflush(stdout);
#endif
}
printf("saving resultat...\n");
Image_marque_1(troisieme, "Egalisations", 0);
Image_TGA_save("Pictures/aaaa_egal.tga", troisieme, 0);
Image_DeAllocate(image); free(image);
Image_DeAllocate(deuxieme); free(deuxieme);
Image_DeAllocate(troisieme); free(troisieme);
return 42;
}
/*::------------------------------------------------------------------::*/
int
Test_Dithering(char *nomsource, int k)
{
Image_Desc *source, *image, *deuxieme, *finale;
Image_Rect rect;
int foo;
int x2, y2;
RGBA ink, pap;
fprintf(stderr, "========== Dithering on %s (%d) =======\n", nomsource, k);
source = Image_TGA_alloc_load(nomsource);
if (NULL == source)
{
fprintf(stderr, "%s:%s err load %s\n", __FILE__, __func__, nomsource);
exit(5);
}
Image_dump_descriptor(source, "just after load");
/*
* est-ce bien necessaire ?
*/
/* Image_egalise_RGB(source, source, 0); */
x2 = source->width / 2; y2 = source->height / 2;
rect.w = x2; rect.h = y2;
rect.x = 0; rect.y = 0;
ink.r = 255, ink.g = 255, ink.b = 100; ink.a = 255;
pap.r = 30, pap.g = 30, pap.b = 155; pap.a = 255;
finale = Image_alloc(source->width, (source->height)*3, 3);
if (NULL == finale)
{
fprintf(stderr, "%s:%s:%d err alloc image\n",
__FILE__, __func__, __LINE__);
exit(5);
}
printf("image finale allocated %p\n", finale);
image = Image_MakeHalfSize(source, 0);
if (NULL == image)
{
fprintf(stderr, "%s:%s:%d err halfsize image\n",
__FILE__, __func__, __LINE__);
exit(5);
}
printf("image Half -> %p\n", image);
Image_DeAllocate(source); free(source);
Image_copy_rect(image, &rect, finale, 0, 0);
deuxieme = Image_clone(image, 0);
printf("image 2 cloned %p\n\n", deuxieme);
foo = Image_dither_Bayer_0(image, deuxieme, 255);
printf("retour Dither_Bayer_0 = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, x2, 0);
Image_txt1_box_0(finale, "Dither_Bayer_0", x2, 0, 4, &pap, &ink, 0);
foo = Image_dither_seuil_random(image, deuxieme, 255);
printf("retour Seuil_Random = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, x2, y2);
Image_txt1_box_0(finale, "Seuil_Random", x2, y2, 4, &pap, &ink, 0);
foo = Image_dither_simple_error(image, deuxieme, 255);
printf("retour Dither_SimpleError = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, 0, y2);
Image_txt1_box_0(finale, "Simple_Error", 0, y2, 4, &pap, &ink, 0);
foo = Image_dither_double_seuil(image, deuxieme, 100, 200, 255);
printf("retour Dither_DoubleSeuil = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, 0, y2*2);
Image_txt1_box_0(finale, "DoubleSeuil", 0, y2*2, 4, &pap, &ink, 0);
foo = Image_dither_3x3_0(image, deuxieme, 127);
printf("retour Dither_3x3_0 = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, x2, y2*2);
Image_txt1_box_0(finale, "3x3 0", x2, y2*2, 4, &pap, &ink, 0);
foo = Image_dither_3x3_1(image, deuxieme, 255);
printf("retour Dither_3x3_1 = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, 0, y2*3);
Image_txt1_box_0(finale, "3x3 1", 0, y2*3, 4, &pap, &ink, 0);
foo = Image_dither_3x3_2(image, deuxieme, 127);
printf("retour Dither_3x3_2 = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, x2, y2*3);
Image_txt1_box_0(finale, "3x3 2", x2, y2*3, 4, &pap, &ink, 0);
foo = Image_dither_bayer8x8rnd(image, deuxieme, 5000, 0);
printf("retour Dither bayer8x8rnd = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, x2, y2*4);
Image_txt1_box_0(finale, "bayer 8x8 rnd rgb", x2, y2*4, 4, &pap, &ink, 0);
foo = Image_dither_bayer8x8rnd(image, deuxieme, 5000, 1);
printf("retour Dither bayer8x8rnd = %d\n", foo);
Image_copy_rect(deuxieme, &rect, finale, 0, y2*4);
Image_txt1_box_0(finale, "bayer 8x8 rnd grey", 0, y2*4, 4, &pap, &ink, 0);
Image_TGA_save("Pictures/aaaa_dithering.tga", finale, 0);
Image_DeAllocate(image); free(image);
Image_DeAllocate(deuxieme); free(deuxieme);
Image_DeAllocate(finale); free(finale);
return 0;
}
/*::------------------------------------------------------------------::*/
/*
* test des marquages
*/
int Test_des_marquages(char *srname, int k1, int k2)
{
/*
* please insert useless code here
*/
return -1;
}
/*::------------------------------------------------------------------::*/
/* new 21 juillet 2007 - ave St Exupery */
int
Test_Effects_A(char *nomsource, int flag)
{
Image_Desc *source, *image, *deuxieme, *finale;
int foo;
int x, y, x2, y2;
RGBA ink, pap;
printf("=== %s %s === %s === %d ===\n", __FILE__, __func__, nomsource, flag);
if (flag)
{
fprintf(stderr, "%s: flag is %d ?\n", __func__, flag);
}
ink.r = 255, ink.g = 255, ink.b = 100; ink.a = 255;
pap.r = 30, pap.g = 30, pap.b = 155; pap.a = 255;
source = Image_TGA_alloc_load(nomsource);
if (NULL==source)
{
fprintf(stderr, "%s : il manque '%s'\n", __func__, nomsource);
exit(1);
}
printf("test effect (%d): image loaded %p\n", flag, source);
/*
* est-ce bien necessaire ?
*/
/* non Image_egalise_RGB(source, source, 0); XXX */
x2 = source->width / 2; y2 = source->height / 2;
finale = Image_clone(source, 0);
printf("image finale cloned %p\n", finale);
image = Image_MakeHalfSize(source, 0);
Image_DeAllocate(source); free(source);
deuxieme = Image_clone(image, 0);
printf("image 2 cloned %p\n\n", deuxieme);
/* first shoot */
foo = Image_water(image, deuxieme, 15);
if (foo) fprintf(stderr, "water -> %d\n", foo);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x, y);
Image_txt1_box_0(finale, "Water", 0, 0, 4, &pap, &ink, 0);
foo = Image_noise(image, deuxieme, 42);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x+x2, y);
Image_txt1_box_0(finale, "noise", x2, 0, 4, &pap, &ink, 0);
foo = Image_center_rotate(image, deuxieme, 23.6);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x, y+y2);
Image_txt1_box_0(finale, "center rotate", 0, y2, 4, &pap, &ink, 0);
foo = Image_effect_x_5(image, deuxieme, 126, 127, 127);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x+x2, y+y2);
Image_txt1_box_0(finale, "effect x 5", x2, y2, 4, &pap, &ink, 0);
Image_TGA_save("Pictures/aaaa_effects_a.tga", finale, 0);
/* second shoot */
foo = Image_scratch(image, deuxieme, 15);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x, y);
Image_txt1_box_0(finale, "Scratch", 0, 0, 4, &pap, &ink, 0);
foo = Image_effect_x_2(image, deuxieme, 126, 127, 127);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x+x2, y+y2);
Image_txt1_box_0(finale, "effect x 2", x2, y2, 4, &pap, &ink, 0);
foo = Image_swap_nibbles(image, deuxieme);
for (x=0; x<x2; x++)
for (y=0; y<y2; y++)
Image_pixel_copy(deuxieme, x, y, finale, x, y+y2);
Image_txt1_box_0(finale, "swap nibbles", 0, y2, 4, &pap, &ink, 0);
Image_TGA_save("Pictures/aaaa_effects_b.tga", finale, 0);
Image_DeAllocate(image); free(image);
Image_DeAllocate(deuxieme); free(deuxieme);
Image_DeAllocate(finale); free(finale);
return 42;
}
/*::------------------------------------------------------------------::*/
int
Test_des_tamppools(char *imgname, int param)
{
void *ptr;
int foo;
printf("=== test des tamppools === %s === %d ===\n", imgname, param);
Image_Pool_infos(0);
ptr = Image_Pool_create("pour un essai", 10, 320, 200);
foo = Image_Pool_describe(ptr, "pour voir...", 0);
foo = Image_Pool_destroy(ptr, "Kill Bill !!!", 0);
Image_Pool_infos(1);
return 42;
}
/*::------------------------------------------------------------------::*/
int Test_des_filtres(char *srcname, int k)
{
Image_Desc *src, *dst;
int foo;
printf("======= LES FILTRES ===[ %s ]==[ %d ]====\n", srcname, k);
src = Image_TGA_alloc_load(srcname);
if (NULL == src)
{
fprintf(stderr, "%s can't load %s\n", __func__, srcname);
return 666;
}
dst = Image_clone(src, 1);
if (NULL == dst)
{
fprintf(stderr, "mem failure in %s\n", __func__);
abort();
}
foo = Image_lissage_3x3(src, dst);
Image_TGA_save("Pictures/filtre-liss3x3.tga", dst, 0);
if (foo) { fprintf(stderr, "%s: liss3x3 -> %d\n", foo); }
foo = Image_filtre_Prewitt(src, dst, 5);
Image_TGA_save("Pictures/filtre-prewitt-5.tga", dst, 0);
foo = Image_filtre_passe_haut(src, dst);
Image_TGA_save("Pictures/filtre-passe-haut.tga", dst, 0);
foo = Image_filtre_Sobel_4(src, dst, 0);
Image_TGA_save("Pictures/filtre-sobel-4.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return 42;
}
/*::------------------------------------------------------------------::*/
/*
* the parameter 'prefix' will be prepended to the generated filenames.
* you can use somthing like "Pictures/foo"
*/
void Test_des_patterns(char *prefix, int foo, int bar)
{
Image_Desc *image;
char filename[1000];
int retc;
printf("============ test des patterns ================\n");
printf("%s:%s: prefix [%s], foo %d, bar %d\n",
__FILE__, __func__, prefix, foo, bar);
image = Image_alloc(320, 200, 3);
strcpy(filename, prefix); strcat(filename, "_000.tga");
fprintf(stderr, "--> %s\n", filename);
retc = Image_pattern_000(image, 100);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
strcpy(filename, prefix); strcat(filename, "_001.tga");
fprintf(stderr, "--> %s\n", filename);
retc = Image_pattern_001(image, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
strcpy(filename, prefix); strcat(filename, "_002.tga");
fprintf(stderr, "--> %s\n", filename);
retc = Image_pattern_002(image, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
strcpy(filename, prefix); strcat(filename, "_005.tga");
fprintf(stderr, "--> %s\n", filename);
retc = Image_pattern_005(image, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
strcpy(filename, prefix); strcat(filename, "_042.tga");
fprintf(stderr, "--> %s\n", filename);
retc = Image_pattern_042(image, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
fprintf(stderr, "===== %s : la serie des 10x ====\n", __func__);
strcpy(filename, prefix); strcat(filename, "_100.tga");
retc = Image_pattern_100(image, 0, 0, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
strcpy(filename, prefix); strcat(filename, "_101.tga");
retc = Image_pattern_101(image, 0, 0, 0);
Image_print_error(filename, retc);
Image_TGA_save(filename, image, 0);
}
/*::------------------------------------------------------------------::*/
/* test des pixelizzzations - 14 octobre 2007 - avenue Sy Exupery
*
*/
int Test_des_pixeliz(char *srcname, int flags)
{
Image_Desc *src, *dst;
int foo;
printf("\nPIXELIZ flags= $%04x\n", flags);
src = Image_TGA_alloc_load(srcname);
printf("test pixeliz: image loaded %p\n", src);
dst = Image_clone(src, 0);
printf("test pixeliz: clone @ %p\n", dst);
foo = Image_pixeliz_X(src, dst);
printf("test pixeliz: X %d\n", foo);
Image_TGA_save("Pictures/aaaa_pixelX.tga", dst, 0);
foo = Image_pixeliz_Y(src, dst);
printf("test pixeliz: Y %d\n", foo);
Image_TGA_save("Pictures/aaaa_pixelY.tga", dst, 0);
Image_DeAllocate(src); free(src);
Image_DeAllocate(dst); free(dst);
return -1;
}
/*::------------------------------------------------------------------::*/
Reference in New Issue Copy Permalink