the great code shaking party
This commit is contained in:
tth
377
Lib/effects.c
Normal file
377
Lib/effects.c
Normal file
@@ -0,0 +1,377 @@
|
||||
/*
|
||||
|
||||
+---------------------------------------+
|
||||
| Effets speciaux sur les images |
|
||||
+---------------------------------------+
|
||||
|
||||
Thierry Boudet <oulala@chez.com>
|
||||
-----------------------------------------
|
||||
vous pouvez aussi aller regarder le module 'combine.c'
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "tthimage.h"
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
* cette func a un defaut: le deplacement est randomatiquement
|
||||
* lineaire, c'est a dire que la probabilite est constante dans
|
||||
* toute l'intensite.
|
||||
*/
|
||||
int
|
||||
Image_water( Image_Desc *source, Image_Desc *but, int intensite )
|
||||
{
|
||||
int x, y, nx, ny, r, g, b, foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
int retry;
|
||||
#endif
|
||||
|
||||
if ( (foo=Image_compare_desc(source, but)) )
|
||||
{
|
||||
fprintf(stderr, "%s : images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (intensite < 1)
|
||||
{
|
||||
fprintf(stderr, "%s : bad intensity %d\n", __func__, intensite);
|
||||
intensite = 1;
|
||||
}
|
||||
|
||||
if (source == but)
|
||||
{
|
||||
fprintf(stderr, "%s : Source & Target are the same image, bad effect expected...\n", __func__ );
|
||||
}
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
retry = 0;
|
||||
#endif
|
||||
|
||||
for (x=0; x<source->width; x++)
|
||||
{
|
||||
for (y=0; y<source->height; y++)
|
||||
{
|
||||
foo = -1;
|
||||
do
|
||||
{
|
||||
nx = x+(rand()%intensite)-(intensite/2);
|
||||
ny = y+(rand()%intensite)-(intensite/2);
|
||||
foo++;
|
||||
} while ( ! ( (nx >= 0) && (ny >=0) &&
|
||||
(nx < source->width) &&
|
||||
(ny < source->height) )
|
||||
);
|
||||
#if DEBUG_LEVEL
|
||||
retry += foo;
|
||||
#endif
|
||||
r = (source->Rpix[ny])[nx];
|
||||
g = (source->Gpix[ny])[nx];
|
||||
b = (source->Bpix[ny])[nx];
|
||||
|
||||
(but->Rpix[y])[x] = r;
|
||||
(but->Gpix[y])[x] = g;
|
||||
(but->Bpix[y])[x] = b;
|
||||
}
|
||||
}
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
if (retry > 0)
|
||||
fprintf(stderr, "image water: %d retries\n", retry);
|
||||
else
|
||||
fprintf(stderr, "image water: NO retry !\n");
|
||||
#endif
|
||||
but->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
* cette fonction peut etre utilisee avec la meme image
|
||||
* en source et en destination.
|
||||
*/
|
||||
int
|
||||
Image_noise(Image_Desc *source, Image_Desc *but, int intensite)
|
||||
{
|
||||
int x, y, r, g, b, foo;
|
||||
|
||||
if ( (foo=Image_compare_desc(source, but)) )
|
||||
{
|
||||
fprintf(stderr, "%s : images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (intensite < 1)
|
||||
{
|
||||
fprintf(stderr, "%s : bad intensity %d\n", __func__, intensite);
|
||||
intensite = 1;
|
||||
}
|
||||
|
||||
for (x=0; x<source->width; x++)
|
||||
{
|
||||
for (y=0; y<source->height; y++)
|
||||
{
|
||||
r = Image_clamp_pixel((source->Rpix[y])[x]
|
||||
+ (rand()%intensite) - (intensite/2));
|
||||
g = Image_clamp_pixel((source->Gpix[y])[x]
|
||||
+ (rand()%intensite) - (intensite/2));
|
||||
b = Image_clamp_pixel((source->Bpix[y])[x]
|
||||
+ (rand()%intensite) - (intensite/2));
|
||||
|
||||
(but->Rpix[y])[x] = r;
|
||||
(but->Gpix[y])[x] = g;
|
||||
(but->Bpix[y])[x] = b;
|
||||
}
|
||||
}
|
||||
|
||||
but->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* 19 Aout 1999
|
||||
|
||||
j'ai rapidement besoin de cette fonction alors je code
|
||||
a la rache :-[ (on appelle aussi c,a le codage 123momo)
|
||||
*/
|
||||
int
|
||||
Image_mirror(Image_Desc *src, Image_Desc *dst, int reserved)
|
||||
{
|
||||
register int x;
|
||||
uint8_t *buffer;
|
||||
int foo, largeur, y;
|
||||
|
||||
if (reserved != 0)
|
||||
fprintf(stderr, "Image_Mirror: reserved must be zero !\n");
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_Mirror: images are differents %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
largeur = src->width;
|
||||
|
||||
if ((buffer = (uint8_t *)malloc(largeur)) == NULL)
|
||||
{
|
||||
fprintf(stderr, "Image_Mirror: no memory for buffer");
|
||||
return BUFFER_NO_MEM;
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
if (src->Rpix != NULL)
|
||||
{
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Rpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Rpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Gpix != NULL)
|
||||
{
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Gpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Gpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Bpix != NULL)
|
||||
{
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Bpix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Bpix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
if (src->Apix != NULL)
|
||||
{
|
||||
for (x=0; x<largeur; x++)
|
||||
buffer[x] = (src->Apix[y])[x];
|
||||
for (x=0; x<largeur; x++)
|
||||
(dst->Apix[y])[x] = buffer[largeur-x-1];
|
||||
}
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
dst->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* new 4 Janvier 2000 */
|
||||
int
|
||||
Image_upside_down(Image_Desc *src, Image_Desc *dst, int reserved)
|
||||
{
|
||||
int foo, y;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_UpsideDown: images are differents %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (0 != reserved)
|
||||
{
|
||||
fprintf(stderr, "%s gni ?\n", __func__);
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
memcpy(dst->Rpix[y], src->Rpix[src->height-(y+1)], src->width);
|
||||
memcpy(dst->Gpix[y], src->Gpix[src->height-(y+1)], src->width);
|
||||
memcpy(dst->Bpix[y], src->Bpix[src->height-(y+1)], src->width);
|
||||
if (src->Apix != NULL)
|
||||
memcpy(dst->Apix[y], src->Apix[src->height-(y+1)], src->width);
|
||||
}
|
||||
dst->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/*
|
||||
* je soupc,onne un bug la dedans... XXX
|
||||
*/
|
||||
int
|
||||
Image_scratch ( Image_Desc *source, Image_Desc * but, long nombre )
|
||||
{
|
||||
int xs, ys, xd, yd;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "Scratching %ld times %p to %p\n", nombre, source, but);
|
||||
#endif
|
||||
|
||||
Image_copy(source, but);
|
||||
|
||||
while (nombre--)
|
||||
{
|
||||
xs = rand() % source->width;
|
||||
ys = rand() % source->height;
|
||||
xd = rand() % source->width;
|
||||
yd = rand() % source->height;
|
||||
|
||||
Image_pixel_copy(source, xs, ys, but, xd, yd);
|
||||
}
|
||||
|
||||
but->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* 7 Sep 1999 */
|
||||
int
|
||||
Image_swap_lines( Image_Desc *src, Image_Desc * dst )
|
||||
{
|
||||
int foo, line;
|
||||
|
||||
if (src == dst)
|
||||
{
|
||||
fprintf(stderr, "Image swap lines: SRC & DST must be different\n");
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image swap lines: images have differents sizes. %d\n",
|
||||
foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (line=0; line<(src->height-1); line+=2)
|
||||
{
|
||||
memcpy(dst->Rpix[line+1], src->Rpix[line], src->width);
|
||||
memcpy(dst->Rpix[line], src->Rpix[line+1], src->width);
|
||||
memcpy(dst->Gpix[line+1], src->Gpix[line], src->width);
|
||||
memcpy(dst->Gpix[line], src->Gpix[line+1], src->width);
|
||||
memcpy(dst->Bpix[line+1], src->Bpix[line], src->width);
|
||||
memcpy(dst->Bpix[line], src->Bpix[line+1], src->width);
|
||||
}
|
||||
|
||||
dst->modified = 1;
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* 7 Sep 1999 */
|
||||
int
|
||||
Image_swap_cols( Image_Desc *src, Image_Desc * dst )
|
||||
{
|
||||
int foo, line, col, tmp, wmax;
|
||||
|
||||
if (src == dst)
|
||||
{
|
||||
fprintf(stderr, "Image_SwapCols: SRC & DST must be different\n");
|
||||
return IMG_OVERWRITE;
|
||||
}
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "Image_SwapCols: images are differents %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
if (src->width & 1)
|
||||
wmax = src->width - 1;
|
||||
else
|
||||
wmax = src->width;
|
||||
fprintf(stderr, "swap cols %d %d\n", src->width, wmax);
|
||||
|
||||
for (line=0; line<src->height; line++)
|
||||
{
|
||||
for (col=0; col<wmax; col+=2)
|
||||
{
|
||||
tmp = src->Rpix[line][col];
|
||||
dst->Rpix[line][col] = src->Rpix[line][col+1];
|
||||
dst->Rpix[line][col+1] = tmp;
|
||||
|
||||
tmp = src->Gpix[line][col];
|
||||
dst->Gpix[line][col] = src->Gpix[line][col+1];
|
||||
dst->Gpix[line][col+1] = tmp;
|
||||
|
||||
tmp = src->Bpix[line][col];
|
||||
dst->Bpix[line][col] = src->Bpix[line][col+1];
|
||||
dst->Bpix[line][col+1] = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
dst->modified = 1;
|
||||
|
||||
return OLL_KORRECT;
|
||||
}
|
||||
|
||||
/*::------------------------------------------------------------------::*/
|
||||
/* 7 Sep 1999 */
|
||||
int
|
||||
Image_swap_nibbles( Image_Desc *src, Image_Desc * dst )
|
||||
{
|
||||
int foo;
|
||||
int x, y;
|
||||
|
||||
if ( (foo=Image_compare_desc(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
for (x=0; x<src->width; x++)
|
||||
{
|
||||
for (y=0; y<src->height; y++)
|
||||
{
|
||||
dst->Rpix[y][x] = ((src->Rpix[y][x] & 0xf0) >> 4) |
|
||||
((src->Rpix[y][x] & 0x0f) << 4);
|
||||
|
||||
#if DEBUG_LEVEL > 1
|
||||
printf ("%02x %02x\n", src->Rpix[y][x], dst->Rpix[y][x]);
|
||||
#endif
|
||||
dst->Gpix[y][x] = ((src->Gpix[y][x] & 0xf0) >> 4) |
|
||||
((src->Gpix[y][x] & 0x0f) << 4);
|
||||
|
||||
dst->Bpix[y][x] = ((src->Bpix[y][x] & 0xf0) >> 4) |
|
||||
((src->Bpix[y][x] & 0x0f) << 4);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return FUNC_IS_BETA;
|
||||
}
|
||||
/*::------------------------------------------------------------------::*/
|
||||
Reference in New Issue
Block a user