1424 lines
38 KiB
C
1424 lines
38 KiB
C
/*
|
|
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>
|
|
|
|
#include "../tthimage.h"
|
|
#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(fname, 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);
|
|
if (foo) {
|
|
fprintf(stderr, "In %s, essai zoom -> %d\n", foo);
|
|
}
|
|
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
|
|
};
|
|
#if 0
|
|
/* WHAT THE HELL is this data thing ? */
|
|
static struct offxy
|
|
{ int x, y; } offsets[] = {
|
|
{ 1, 0 },
|
|
{ 2, 0 },
|
|
{ 2, 1 },
|
|
{ 2, 2 },
|
|
{ 1, 2 },
|
|
{ 0, 2 },
|
|
{ 0, 1 },
|
|
{ 0, 0 }
|
|
};
|
|
#endif
|
|
|
|
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", __func__, 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;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|