Bibliothèque de traitements d'images en virgule flottante.
http://la.buvette.org/photos/cumul/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
323 lines
7.3 KiB
323 lines
7.3 KiB
/* |
|
* SPECIAL EFFECTS |
|
* |
|
* Du code bien cracra / tTh / Tetalab |
|
*/ |
|
#include <stdio.h> |
|
#include <string.h> |
|
#include <stdlib.h> |
|
#include <malloc.h> |
|
|
|
#include "../floatimg.h" |
|
|
|
#include "fonctions.h" |
|
#include "sfx.h" |
|
|
|
/* -------------------------------------------------------------- */ |
|
/* here are global vars exported by the main module |
|
*/ |
|
extern int verbosity; |
|
|
|
/* -------------------------------------------------------------- */ |
|
/* nouveau du 27 decembre 2020, un soir de grand froid... */ |
|
|
|
int octotree_classif(FloatImg *pimg, int notused) |
|
{ |
|
int foo; |
|
float mm[6], means[4]; |
|
|
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused); |
|
|
|
foo = fimg_meanvalues(pimg, means); |
|
if (foo) { |
|
fprintf(stderr, "oups %d in meanvalues\n", foo); |
|
return foo; |
|
} |
|
fprintf(stderr, "means: %11f %11f %11f\n", means[0], means[1], means[2]); |
|
|
|
foo = fimg_get_minmax_rgb(pimg, mm); |
|
if (foo) { |
|
fprintf(stderr, "oups %d in get minmax\n", foo); |
|
return foo; |
|
} |
|
fimg_print_minmax(mm, __func__); |
|
|
|
/* |
|
* compute the height center points */ |
|
|
|
|
|
|
|
return -1; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
/* nouveau du 19 decembre 2020, pour le grand ecran de da Scritch */ |
|
|
|
int upside_down(FloatImg *pimg) |
|
{ |
|
float *rowpix; |
|
float *Ps, *Pd; |
|
int Os, Od; /* offset of lines */ |
|
int wsz; |
|
int ya, y2; |
|
|
|
if (verbosity>1) fprintf(stderr, "%s: image width is %d\n", |
|
__func__, pimg->width); |
|
|
|
rowpix = calloc(pimg->width, sizeof(float)); |
|
if (NULL==rowpix) { |
|
fprintf(stderr, "%s : memory full\n", __func__); |
|
exit(1); |
|
} |
|
|
|
wsz = pimg->width * sizeof(float); |
|
if (verbosity>1) fprintf(stderr, "%s: wsx = %d\n", __func__, wsz); |
|
|
|
for (ya=0; ya<pimg->height/2; ya++) { |
|
|
|
y2 = pimg->height - (ya+1); |
|
Os = (pimg->width * ya); |
|
Od = (pimg->width * y2); |
|
|
|
/* let's go, crash coredumping... */ |
|
Ps = pimg->R + Os; |
|
Pd = pimg->R + Od; |
|
memcpy(rowpix, Ps, wsz); |
|
memcpy(Ps, Pd, wsz); |
|
memcpy(Pd, rowpix, wsz); |
|
|
|
Ps = pimg->G + Os; |
|
Pd = pimg->G + Od; |
|
memcpy(rowpix, Ps, wsz); |
|
memcpy(Ps, Pd, wsz); |
|
memcpy(Pd, rowpix, wsz); |
|
|
|
Ps = pimg->B + Os; |
|
Pd = pimg->B + Od; |
|
memcpy(rowpix, Ps, wsz); |
|
memcpy(Ps, Pd, wsz); |
|
memcpy(Pd, rowpix, wsz); |
|
} |
|
|
|
free(rowpix); |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
/* nouveau du 9 decembre 2020, en ecoutant le Fermion raconter du |
|
superbe portnawak */ |
|
int bouger_les_pixels(FloatImg *pimg, int intensite) |
|
{ |
|
int x, y, nx, ny; |
|
float rgb[3]; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, intensite); |
|
#endif |
|
|
|
if (intensite < 1) { |
|
fprintf(stderr, "%s: %d bad intensity\n", __func__, intensite); |
|
return -1; |
|
} |
|
|
|
for (x=0; x<pimg->width; x++) { |
|
for (y=0; y<pimg->height; y++) { |
|
|
|
nx = x+(rand()%intensite)-(intensite/2); |
|
ny = y+(rand()%intensite)-(intensite/2); |
|
|
|
if ( nx<0 || ny<0 || nx>=pimg->width |
|
|| ny>=pimg->height ) |
|
continue; |
|
|
|
fimg_get_rgb(pimg, nx, ny, rgb); |
|
fimg_put_rgb(pimg, x, y, rgb); |
|
|
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
/* nouveau du 9 decembre 2020, en ecoutant les Cernettes */ |
|
int mirror_split(FloatImg *pimg, int kaboo) |
|
{ |
|
int line, x, xs, xd; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, kaboo); |
|
#endif |
|
|
|
for (line=0; line<pimg->height; line++) { |
|
for (x=0; x<pimg->width/2; x++) { |
|
xs = (pimg->width * line) + x; |
|
xd = (pimg->width * line) + (pimg->width -x); |
|
pimg->R[xd] = pimg->R[xs]; |
|
pimg->G[xd] = pimg->G[xs]; |
|
pimg->B[xd] = pimg->B[xs]; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
/* nouveau du 20 novembre 2020, pour encoder une vidz du vernissage |
|
* du festival Sauvageonnes de Mixart-Myrys */ |
|
int des_bords_sombres_a(FloatImg *pimg, int offset) |
|
{ |
|
float coef; |
|
int xpos, xp2, lidx, y; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, offset); |
|
#endif |
|
|
|
if (offset<0 || offset>=pimg->width) { |
|
fprintf(stderr, "%s offset %d is bad\n", __func__, offset); |
|
return -66; |
|
} |
|
|
|
for (y=0; y<pimg->height; y++) { |
|
lidx = y * pimg->width; /* start of the |
|
'y' line */ |
|
for (xpos=0; xpos<offset; xpos++) { |
|
coef = (float)xpos / (float)offset; |
|
pimg->R[xpos+lidx] *= coef; |
|
pimg->G[xpos+lidx] *= coef; |
|
pimg->B[xpos+lidx] *= coef; |
|
xp2 = pimg->width-xpos; |
|
pimg->R[xp2+lidx] *= coef; |
|
pimg->G[xp2+lidx] *= coef; |
|
pimg->B[xp2+lidx] *= coef; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int trinarize(FloatImg *pimg, int notused) |
|
{ |
|
float mm[6], mRa, mGa, mBa, mRb, mGb, mBb; |
|
float *fptr; |
|
int foo, size; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused); |
|
#endif |
|
|
|
foo = fimg_get_minmax_rgb(pimg, mm); |
|
mRa = (mm[1] - mm[0]) * 0.33333; |
|
mGa = (mm[3] - mm[2]) * 0.33333; |
|
mBa = (mm[5] - mm[4]) * 0.33333; |
|
mRb = (mm[1] - mm[0]) * 0.66666; |
|
mGb = (mm[3] - mm[2]) * 0.66666; |
|
mBb = (mm[5] - mm[4]) * 0.66666; |
|
|
|
size = pimg->width * pimg->height; |
|
|
|
for (foo=0; foo<size; foo++) { |
|
|
|
fptr = pimg->R; |
|
if (fptr[foo] < mRa || fptr[foo] > mRb) |
|
fptr[foo] = mm[0]; |
|
else |
|
fptr[foo] = mm[1]; |
|
|
|
fptr = pimg->G; |
|
if (fptr[foo] < mGa || fptr[foo] > mGb) |
|
fptr[foo] = mm[2]; |
|
else |
|
fptr[foo] = mm[3]; |
|
|
|
fptr = pimg->B; |
|
if (fptr[foo] < mBa || fptr[foo] > mBb) |
|
fptr[foo] = mm[4]; |
|
else |
|
fptr[foo] = mm[5]; |
|
|
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int binarize(FloatImg *pimg, int notused) |
|
{ |
|
float mm[6], mR, mG, mB; |
|
int foo, size; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused); |
|
#endif |
|
|
|
foo = fimg_get_minmax_rgb(pimg, mm); |
|
mR = (mm[1] - mm[0]) / 2.0; |
|
mG = (mm[3] - mm[2]) / 2.0; |
|
mB = (mm[5] - mm[4]) / 2.0; |
|
|
|
if (verbosity > 1) |
|
fprintf(stderr, "%s: %f %f %f\n", __func__, mR, mG, mB); |
|
|
|
size = pimg->width * pimg->height; |
|
|
|
for (foo=0; foo<size; foo++) { |
|
if (pimg->R[foo] < mR) pimg->R[foo] = mm[0]; |
|
else pimg->R[foo] = mm[1]; |
|
if (pimg->G[foo] < mG) pimg->G[foo] = mm[2]; |
|
else pimg->G[foo] = mm[3]; |
|
if (pimg->B[foo] < mB) pimg->B[foo] = mm[4]; |
|
else pimg->B[foo] = mm[5]; |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int brotche_rand48_a(FloatImg *fimg, float ratio, float mval) |
|
{ |
|
int nbpix, todo, foo; |
|
int x, y; |
|
float fval; |
|
|
|
nbpix = fimg->width * fimg->height; |
|
todo = (int)((float)nbpix * ratio); |
|
if (verbosity > 1) { |
|
fprintf(stderr, "%s: ratio %f nbpix %d todo %d\n", __func__, |
|
ratio, nbpix, todo); |
|
} |
|
|
|
for (foo=0; foo<todo; foo++) |
|
{ |
|
fval = (float)drand48() * mval; |
|
x = rand() % fimg->width; |
|
y = rand() % fimg->height; |
|
fimg_plot_rgb(fimg, x, y, fval, fval, fval); |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int brotche_rand48_b(FloatImg *fimg, float ratio, float mval) |
|
{ |
|
int nbpix, todo, foo; |
|
int x, y; |
|
float fval; |
|
|
|
nbpix = fimg->width * fimg->height; |
|
todo = (int)((float)nbpix * ratio); |
|
if (verbosity > 1) { |
|
fprintf(stderr, "%s: ratio %f nbpix %d todo %d\n", __func__, |
|
ratio, nbpix, todo); |
|
} |
|
|
|
for (foo=0; foo<todo; foo++) |
|
{ |
|
fval = (float)drand48() * mval; |
|
x = 1 + (rand() % (fimg->width-2)); |
|
y = rand() % fimg->height; |
|
fimg_plot_rgb(fimg, x-1, y, fval, 0.0, 0.0); |
|
fimg_plot_rgb(fimg, x , y, 0.0, 0.0, fval); |
|
fimg_plot_rgb(fimg, x+1, y, 0.0, fval, 0.0); |
|
} |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
|
|
|