FloatImg4PythonBinding/lib/operators.c

/*
 *		OPERATORS
 *
 *
 */

#include  <stdio.h>
#include  <stdlib.h>
#include  <unistd.h>
#include  <string.h>
#include  <math.h>

#include  "../floatimg.h"

extern int verbosity;		/* must be declared around main() */

/* ---------------------------------------------------------------- */
/*
 * 		A + B -> D
 * 				why is this func so slow ?
 */
int fimg_add_3(FloatImg *a, FloatImg *b, FloatImg *d)
{
int		idx, nbpixels;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, a, b, d);
#endif

if (3 != a->type || 3 != b->type || 3 != d->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	} 

nbpixels = a->width * a->height;

for (idx=0; idx<nbpixels; idx++) {
	d->R[idx] = a->R[idx] + b->R[idx];
	d->G[idx] = a->G[idx] + b->G[idx];
	d->B[idx] = a->B[idx] + b->B[idx];
	}

return 0;
}
/* ---------------------------------------------------------------- */
/*
 * 		B += A		may be faster than fimg_add_3 ?
 */
int fimg_add_2(FloatImg *a, FloatImg *b)
{
int		idx, nbpixels;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, a, b);
#endif

if (3 != a->type || 3 != b->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	}

nbpixels = a->width * a->height;

for (idx=0; idx<nbpixels; idx++) {
	b->R[idx] += a->R[idx];
	b->G[idx] += a->G[idx];
	b->B[idx] += a->B[idx];
	}

return 0;
}
/* ---------------------------------------------------------------- */
/*
 *		A - B -> D
 */
int fimg_sub_3(FloatImg *a, FloatImg *b, FloatImg *d)
{
int		idx, nbpixels;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, a, b, d);
#endif

if (3 != a->type || 3 != b->type || 3 != d->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	}

nbpixels = a->width * a->height;

/*		maybe we can speedup this loop for
 *		avoiding the cache strashing ?
 */
for (idx=0; idx<nbpixels; idx++) {
	d->R[idx] = fabs(a->R[idx] - b->R[idx]);
	d->G[idx] = fabs(a->G[idx] - b->G[idx]);
	d->B[idx] = fabs(a->B[idx] - b->B[idx]);
	}

return 0;
}
/* ---------------------------------------------------------------- */
/*
 * 		B *= A		may be faster than fimg_mul_3 ?
 */
int fimg_mul_2(FloatImg *a, FloatImg *b)
{
int		idx, nbpixels;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, a, b);
#endif

if (3 != a->type || 3 != b->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	}

nbpixels = a->width * a->height;

for (idx=0; idx<nbpixels; idx++) {
	b->R[idx] *= a->R[idx];
	b->G[idx] *= a->G[idx];
	b->B[idx] *= a->B[idx];
	}

}
/* ---------------------------------------------------------------- */
/*
 *		A * B -> D
 */
int fimg_mul_3(FloatImg *a, FloatImg *b, FloatImg *d)
{
int		idx, nbpixels;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, a, b, d);
#endif

if (3 != a->type || 3 != b->type || 3 != d->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	} 

nbpixels = a->width * a->height;

for (idx=0; idx<nbpixels; idx++) {
	d->R[idx] = a->R[idx] * b->R[idx];
	d->G[idx] = a->G[idx] * b->G[idx];
	d->B[idx] = a->B[idx] * b->B[idx];
	}

return 0;
}
/* ---------------------------------------------------------------- */
int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d)
{
int		idx, nbiter;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, a, b, d);
#endif

if (3 != a->type || 3 != b->type || 3 != d->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	}

nbiter = a->width * a->height * 3;

for (idx=0; idx<nbiter; idx++) {
	if (a->R[idx] > b->R[idx])
			d->R[idx] = a->R[idx];
	else
			d->R[idx] = b->R[idx];
	}

return 0;
}
/* ---------------------------------------------------------------- */
int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d)
{
int		idx, nbiter;

#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, a, b, d);
#endif

if (3 != a->type || 3 != b->type || 3 != d->type) {
	fprintf(stderr, "%s : got a bad type fimg\n", __func__);
	return -8;
	}

nbiter = a->width * a->height * 3;

for (idx=0; idx<nbiter; idx++) {
	if (a->R[idx] < b->R[idx])
			d->R[idx] = a->R[idx];
	else
			d->R[idx] = b->R[idx];
	}

return 0;
}
/* ---------------------------------------------------------------- */