442 lines
12 KiB
C
442 lines
12 KiB
C
/*
|
|
SPECIALS EFFECTS
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "tga_outils.h"
|
|
|
|
/*::------------------------------------------------------------------::*/
|
|
#define EFF_4BITS 4
|
|
#define EFF_CLASS0 5
|
|
#define EFF_DECOMP 6
|
|
#define EFF_FLATGRAY 7
|
|
#define EFF_GRAY 9
|
|
#define EFF_GRAYK 11
|
|
#define EFF_MOSAIC 13
|
|
#define EFF_MOSAIC0 14
|
|
#define EFF_PHMATON 15 /* new 30 avril 2007 */
|
|
#define EFF_MIRROR 16
|
|
#define EFF_EXTRBIT0 17 /* new 11 mars 2015 */
|
|
#define EFF_EXTRBIT1 18 /* new 11 mars 2015 */
|
|
#define EFF_NEGATE 20
|
|
#define EFF_SEUIL 22
|
|
#define EFF_DEGOULE 23 /* new octobre 2015 */
|
|
#define EFF_NOISE 27
|
|
#define EFF_PIXELX 33
|
|
#define EFF_PIXELY 34 /* new 30 mars 2007 */
|
|
#define EFF_FIVE 35 /* new 16 dec 2007 */
|
|
#define EFF_WARP_0 36 /* new 17 janv 2015 */
|
|
#define EFF_RECURSE 40
|
|
#define EFF_RGBMSKH 41
|
|
#define EFF_RGBMSKV 42
|
|
#define EFF_RGBMSK2 43
|
|
#define EFF_RGBMSKR 44
|
|
#define EFF_BICOLOR0 46 /* new 17 janv 2010 */
|
|
#define EFF_BICOLOR1 47 /* new 18 janv 2010 */
|
|
#define EFF_BICOLOR2 48 /* new 22 janv 2010 */
|
|
#define EFF_ROT4PIX 51
|
|
#define EFF_CONT2X2 52 /* new 1 sept 2008 */
|
|
#define EFF_CONT2X2G 53 /* new 8 sept 2008 */
|
|
#define EFF_SCRATCH 54
|
|
#define EFF_SINW0 55
|
|
#define EFF_SINW1 56
|
|
#define EFF_SWAPCOL 58
|
|
#define EFF_SWAPNIBBLE 59
|
|
#define EFF_UPDOWN 65
|
|
#define EFF_SHIFT_XY 66 /* new 8 mai 2009 */
|
|
#define EFF_WATER 72
|
|
#define EFF_FUKUNG 75
|
|
#define EFF_CLASS1 83 /* new 20 nov 2013 */
|
|
#define EFF_GLITCH 87 /* new 13 oct 2014 */
|
|
#define EFF_X0 100
|
|
#define EFF_X1 101
|
|
#define EFF_X2 102
|
|
#define EFF_X3 103
|
|
#define EFF_X4 104
|
|
#define EFF_X5 105
|
|
|
|
mot_clef mots_clef[] =
|
|
{
|
|
{ "4bits", EFF_4BITS, "", "and 0xf0" },
|
|
{ "class0", EFF_CLASS0, "", "experimental" },
|
|
{ "decomp", EFF_DECOMP, "f", "flag: print colors" },
|
|
{ "flatgray", EFF_FLATGRAY, "i", "detect flatgray zones" },
|
|
{ "gray", EFF_GRAY, "", "" },
|
|
{ "grayk", EFF_GRAYK, "iii", "3 coefs" },
|
|
{ "mirror", EFF_MIRROR, "", "" },
|
|
{ "extrbits0", EFF_EXTRBIT0, "iii", "shifts for r, g & b" },
|
|
{ "mosaic", EFF_MOSAIC, "", "?" },
|
|
{ "mosaic0", EFF_MOSAIC0, "iif", "?" },
|
|
{ "photomaton", EFF_PHMATON, "", "" },
|
|
{ "negate", EFF_NEGATE, "", "" },
|
|
{ "seuil", EFF_SEUIL, "iii", "rgb thresholds" },
|
|
{ "degoule", EFF_DEGOULE, "ii", "k1 & k2 ? wtf ?" },
|
|
{ "noise", EFF_NOISE, "i", "0..100" },
|
|
{ "pixelX", EFF_PIXELX, "", "prototype" },
|
|
{ "pixelY", EFF_PIXELY, "", "prototype" },
|
|
{ "efive", EFF_FIVE, "", "got it, code it" },
|
|
{ "warp0", EFF_WARP_0, "dii", "angle xc yc" },
|
|
{ "recurse", EFF_RECURSE, "i", "classic and recursif" },
|
|
{ "rgbmskh", EFF_RGBMSKH, "i", "'par' is a gray level" },
|
|
{ "rgbmskv", EFF_RGBMSKV, "i", "'par' is a gray level" },
|
|
{ "rgbmsk2", EFF_RGBMSK2, "i", "'par' is a gray level" },
|
|
{ "rgbmskr", EFF_RGBMSKR, "i", "'par' is a gray level" },
|
|
{ "bicolor0", EFF_BICOLOR0, "i", "?" },
|
|
{ "bicolor1", EFF_BICOLOR1, "ii", "..." },
|
|
{ "rot4pix", EFF_ROT4PIX, "i", "???" },
|
|
{ "cont2x2", EFF_CONT2X2, "", "contours 2x2 en auto" },
|
|
{ "cont2x2g", EFF_CONT2X2G, "", "contours 2x2 sur le gris" },
|
|
{ "scratch", EFF_SCRATCH, "i", "coredumper :)" },
|
|
{ "sinwave1", EFF_SINW1, "dddddd", "strange effect" },
|
|
{ "swapcol", EFF_SWAPCOL, "s", "rg rb bg" },
|
|
{ "swapnibble", EFF_SWAPNIBBLE, "", "swap all pix nibbles" },
|
|
{ "updown", EFF_UPDOWN, "", "upside down" },
|
|
{ "shift_xy", EFF_SHIFT_XY, "ii", "les deux offsets" },
|
|
{ "water", EFF_WATER, "i", "'par' is water distance" },
|
|
/* { "fukung", EFF_FUKUNG, "i", "OMG ! WTF ?" }, */
|
|
{ "class1", EFF_CLASS1, "iiii", "R G B diameter" },
|
|
{ "glitch", EFF_GLITCH, "si", "type nbre" },
|
|
{ "x0", EFF_X0, "iii", "3 thresholds for r, g, b" },
|
|
{ "x1", EFF_X1, "", "xor other componant" },
|
|
{ "x2", EFF_X2, "iii", "trigonometry" },
|
|
{ "x3", EFF_X3, "iis", "" },
|
|
{ "x4", EFF_X4, "i", "essai Aug 2008" },
|
|
{ "x5", EFF_X5, "iii", "essai Sept 2008" },
|
|
{ NULL, 0, NULL, NULL }
|
|
};
|
|
/*::------------------------------------------------------------------::*/
|
|
void usage(int flag)
|
|
{
|
|
fprintf(stderr, "*** tga_effects v 0.1.56 [%s] %s\n",
|
|
TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
|
|
|
|
fprintf(stderr, "\nUsage:\n");
|
|
fprintf(stderr, "\ttga_effects <src.tga> EFF <dst.tga> [p1] ... [p8]\n");
|
|
if (flag)
|
|
{
|
|
Image_print_version(0);
|
|
liste_mots_clefs(mots_clef, 42);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "\ttry 'tga_effects list' for a list.\n");
|
|
}
|
|
exit(5);
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/* fonction codee a la rache le 8 septembre 2008.
|
|
* a passer un jour ou l'autre dans la libimage */
|
|
int contours_du_gris(Image_Desc *src, Image_Desc *dst)
|
|
{
|
|
Image_Desc *tmp;
|
|
int foo;
|
|
|
|
tmp = Image_clone(src, 1);
|
|
|
|
foo = Image_to_gray(src, tmp, 0);
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "to_gray %d\n", foo);
|
|
#endif
|
|
|
|
foo = Image_seuil_RGB(tmp, tmp, 64, 128, 192);
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "seuil rgb %d\n", foo);
|
|
#endif
|
|
|
|
Image_2x2_contours_0(tmp);
|
|
Image_copy(tmp, dst);
|
|
|
|
return 42;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
static int do_classif_1(Image_Desc *img, int kr, int kg, int kb, int diam)
|
|
{
|
|
int foo;
|
|
Une_Classe_Sph classes[2];
|
|
int r, g, b;
|
|
Image_Rect zone;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "%s ( %p %d %d %d %d )\n", __func__, img, kr, kg, kb, diam);
|
|
#endif
|
|
|
|
zone.x = zone.y = 0;
|
|
zone.w = img->width;
|
|
zone.h = img->height;
|
|
|
|
foo = Image_stats_zone_0(img, &zone, &r, &g, &b, NULL, NULL, NULL);
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "%s, stats -> %d %d %d\n", __func__, r, g, b);
|
|
#endif
|
|
|
|
classes[0].rc = r; classes[0].gc = g; classes[0].bc = b;
|
|
classes[0].rad = 30;
|
|
classes[0].r = classes[0].g = 50; classes[0].b = 200;
|
|
|
|
classes[1].rc = kr; classes[1].gc = kg; classes[1].bc = kb;
|
|
classes[1].rad = diam;
|
|
classes[1].r = classes[1].g = 250; classes[1].b = 20;
|
|
|
|
if (must_be_verbose()) {
|
|
Image_display_classes(classes, 2, "umpf", 0);
|
|
}
|
|
|
|
foo = Image_classif_1(img, img, classes, 2, 0);
|
|
fprintf(stderr, "classif 1 -> %d\n", foo);
|
|
|
|
return FUNC_IS_BETA;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/* new 13 OCT 2014 - comburant: Kellegen 8.0 50cl */
|
|
static int do_glitch(Image_Desc *src, Image_Desc *dst, char *type, int nbre)
|
|
{
|
|
int foo;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "%s :\n\t%p %p %s %d\n", __func__,
|
|
src, dst, type, nbre);
|
|
#endif
|
|
|
|
foo = Image_Glitch_simple(src, dst, nbre);
|
|
fprintf(stderr, "glitch simple -> %d\n", foo);
|
|
|
|
return 0;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|
|
/*
|
|
* argv[1] source.tga
|
|
* argv[2] type de l'effet
|
|
* argv[3] destination.tga
|
|
*/
|
|
#define FIRST_PARAM 4
|
|
int main(int argc, char *argv[])
|
|
{
|
|
Image_Desc *src, *dst;
|
|
int foo;
|
|
int commande, nbargs, idx;
|
|
double angle;
|
|
int xc, yc;
|
|
|
|
/*
|
|
* USE GETOPT HERE
|
|
*/
|
|
|
|
dump_command_line(argc, argv, 0);
|
|
if (argc==2 && !strcmp(argv[1], "-?")) usage(0);
|
|
if (argc==2 && !strcmp(argv[1], "list")) usage(1);
|
|
if (argc < 4) usage(0);
|
|
|
|
srand(getpid());
|
|
|
|
/* recherche du type d'effet demande */
|
|
idx = cherche_mot_clef(argv[2], mots_clef, &commande, &nbargs);
|
|
if (idx < 0)
|
|
{
|
|
fprintf(stderr, "tga_effects: mot-clef %s inconnu...\n", argv[2]);
|
|
exit (5);
|
|
}
|
|
|
|
if ( (argc-nbargs) != FIRST_PARAM )
|
|
{
|
|
fprintf(stderr, "%s: bad number of parameters\n", argv[0]);
|
|
exit(5);
|
|
}
|
|
|
|
/* analyse des parametres */
|
|
foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PARAM);
|
|
|
|
if ((src = Image_TGA_alloc_load(argv[1]))==NULL)
|
|
{
|
|
fprintf(stderr, "tga_effect: can't load image %s\n", argv[1]);
|
|
exit(5);
|
|
}
|
|
if ( (dst=Image_clone(src, 1)) == NULL )
|
|
{
|
|
fprintf(stderr, "tga_effect: can't clone %p\n", src);
|
|
exit(1);
|
|
}
|
|
/* XXX ne serait-il pas de bon ton d'effacer l'image de destination ? */
|
|
|
|
switch (commande)
|
|
{
|
|
case EFF_4BITS:
|
|
foo = Image_col4bits_and(src, dst);
|
|
break;
|
|
case EFF_CLASS0:
|
|
foo = Image_classif_0(src, dst);
|
|
break;
|
|
case EFF_DECOMP:
|
|
foo = Image_decompose(src, dst, GFP(0));
|
|
break;
|
|
case EFF_FLATGRAY:
|
|
foo = Image_detect_flat_gray(src, dst, GIP(0), 0);
|
|
break;
|
|
case EFF_GRAY:
|
|
foo = Image_to_gray(src, dst, 0);
|
|
break;
|
|
case EFF_GRAYK:
|
|
foo = Image_to_gray_k(src, dst, GIP(0), GIP(1), GIP(2), 0);
|
|
break;
|
|
case EFF_MIRROR:
|
|
foo = Image_mirror(src, dst, 0);
|
|
break;
|
|
case EFF_EXTRBIT0:
|
|
foo = Image_extrbits_0(src, dst, GIP(0), GIP(1), GIP(2));
|
|
break;
|
|
case EFF_MOSAIC:
|
|
foo = Image_mosaic_simple(src, dst);
|
|
break;
|
|
case EFF_MOSAIC0:
|
|
/* explanation of the parameters, please */
|
|
foo = Image_mosaic_0(src, dst, GIP(0), GIP(1), GFP(2));
|
|
break;
|
|
case EFF_PHMATON:
|
|
foo = Image_photomaton_0(src, dst);
|
|
break;
|
|
case EFF_NEGATE:
|
|
foo = Image_negate(src, dst);
|
|
break;
|
|
case EFF_SEUIL:
|
|
foo = Image_seuil_RGB(src, dst, GIP(0), GIP(1), GIP(2));
|
|
break;
|
|
case EFF_DEGOULE:
|
|
foo = Image_degouline_0(src, dst, GIP(0), GIP(1));
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "Degouline ---> %d\n", foo);
|
|
#endif
|
|
break;
|
|
case EFF_NOISE:
|
|
foo = Image_noise(src, dst, GIP(0));
|
|
break;
|
|
case EFF_PIXELX:
|
|
fprintf(stderr, "Experimental : pixel X !\n");
|
|
foo = Image_pixeliz_X(src, dst);
|
|
break;
|
|
case EFF_PIXELY:
|
|
fprintf(stderr, "Experimental : pixel Y!\n");
|
|
foo = Image_pixeliz_Y(src, dst);
|
|
break;
|
|
case EFF_FIVE: /* XXX */
|
|
foo = Image_effect_x_5(src, dst, 0, 0, 0);
|
|
break;
|
|
case EFF_WARP_0:
|
|
angle = 33.5;
|
|
xc = GIP(1); yc = GIP(2);
|
|
fprintf(stderr, "WARP_0 %f %d %d\n", angle, xc, yc);
|
|
foo = Image_warp_essai_0(src, dst, angle, xc, yc);
|
|
fprintf(stderr, " -> %d\n", foo);
|
|
break;
|
|
case EFF_RECURSE:
|
|
fprintf(stderr, "RECURSE EXPERIMENTAL !\n");
|
|
foo = Image_call_recursion_0(src, dst, GIP(0));
|
|
break;
|
|
case EFF_RGBMSKH:
|
|
foo = Image_rgbmask_H(src, dst, GIP(0));
|
|
break;
|
|
case EFF_RGBMSKV:
|
|
foo = Image_rgbmask_V(src, dst, GIP(0));
|
|
break;
|
|
case EFF_RGBMSK2:
|
|
foo = Image_rgbmask_2(src, dst, GIP(0));
|
|
break;
|
|
case EFF_RGBMSKR:
|
|
foo = Image_rgbmask_R(src, dst, GIP(0));
|
|
break;
|
|
case EFF_BICOLOR0:
|
|
foo = Image_BiColor_0(src, dst, GIP(0));
|
|
break;
|
|
case EFF_BICOLOR1:
|
|
foo = Image_BiColor_1(src, dst, GIP(0), GIP(1));
|
|
break;
|
|
case EFF_ROT4PIX:
|
|
foo = Image_2x2_rot4pix(src, dst, GIP(0));
|
|
break;
|
|
case EFF_CONT2X2:
|
|
Image_AutoSeuilRGB(src, dst);
|
|
foo = Image_2x2_contours_0(dst);
|
|
break;
|
|
case EFF_CONT2X2G:
|
|
foo = contours_du_gris(src, dst);
|
|
break;
|
|
case EFF_SCRATCH:
|
|
foo = Image_scratch(src, dst, GIP(0));
|
|
break;
|
|
case EFF_SWAPCOL:
|
|
Image_copy(src, dst);
|
|
foo = Image_swap_colors(dst, GSP(0));
|
|
break;
|
|
case EFF_SWAPNIBBLE:
|
|
foo = Image_swap_nibbles(src, dst);
|
|
break;
|
|
case EFF_UPDOWN:
|
|
foo = Image_upside_down(src, dst, 0);
|
|
break;
|
|
case EFF_SHIFT_XY:
|
|
foo = Image_shift_xy(src, dst, GIP(0), GIP(1));
|
|
break;
|
|
|
|
case EFF_WATER:
|
|
foo = Image_water(src, dst, GIP(0));
|
|
break;
|
|
|
|
case EFF_CLASS1:
|
|
/* XXX not very trustable */
|
|
foo = do_classif_1(dst, GIP(0), GIP(1), GIP(2), GIP(3));
|
|
break;
|
|
|
|
/* new 13 october 2014 */
|
|
case EFF_GLITCH:
|
|
foo = do_glitch(src, dst, GSP(0), GIP(1));
|
|
fprintf(stderr, "do glitch -> %d\n", 0);
|
|
break;
|
|
|
|
case EFF_X0:
|
|
foo = Image_effect_x_0(src, dst, GIP(0), GIP(1), GIP(2));
|
|
break;
|
|
case EFF_X1:
|
|
foo = Image_effect_x_1(src, dst);
|
|
break;
|
|
case EFF_X2:
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "\teff X2 badly implemented :)\n");
|
|
#endif
|
|
foo = Image_effect_x_2(src, dst, 12, 12, 0);
|
|
break;
|
|
case EFF_X3:
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "\teff X3 badly implemented :)\n");
|
|
#endif
|
|
foo = Image_effect_x_3(src, dst, GIP(0), GIP(1), GSP(2));
|
|
break;
|
|
case EFF_X4:
|
|
foo = Image_effect_x_4(src, dst, GIP(0));
|
|
break;
|
|
case EFF_X5:
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "\teff X5 badly implemented :)\n");
|
|
#endif
|
|
foo = Image_effect_x_5(src, dst, GIP(0), GIP(1), GIP(2));
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "%s invalid command %d, plopped out\n",
|
|
argv[0], commande);
|
|
foo = 666;
|
|
break;
|
|
}
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, "%s: return code is %d\n", __FILE__, foo);
|
|
puts(""); /* make a nicer display in debug mode */
|
|
#endif
|
|
|
|
foo = Image_TGA_save(argv[3], dst, 0);
|
|
|
|
return 0;
|
|
}
|
|
/*::------------------------------------------------------------------::*/
|