FloatImg/Fonderie/sfx.c

/*
 *		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;
}
/* -------------------------------------------------------------- */