285 lines
6.2 KiB
C
285 lines
6.2 KiB
C
/*
|
|
* Floating filters are all WIP !
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <float.h>
|
|
|
|
#include "../floatimg.h"
|
|
|
|
extern int verbosity;
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
int fimg_show_filter(char *title, FimgFilter3x3 *filtr)
|
|
{
|
|
float *M; /* alias of filter matrix */
|
|
int idx;
|
|
float sum, value;
|
|
|
|
if (title) fprintf(stderr, "--------- %s ---------\n", title);
|
|
|
|
M = filtr->matrix; /* aliasing here */
|
|
|
|
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[0], M[1], M[2]);
|
|
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[3], M[4], M[5]);
|
|
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[6], M[7], M[8]);
|
|
|
|
sum = 0.0;
|
|
for (idx=0; idx<9; idx++) sum += M[idx];
|
|
fprintf(stderr, " sum: %8.3f\n", sum);
|
|
fprintf(stderr, " mult: %8.3f\n", filtr->mult);
|
|
fprintf(stderr, " offset: %8.3f\n", filtr->offset);
|
|
|
|
value = (sum * filtr->mult) + filtr->offset;
|
|
fprintf(stderr, " value: %8.3f\n", value);
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
|
|
{
|
|
int x, y, w, h, of;
|
|
float *pr, *pg, *pb; /* alias for src pix filds */
|
|
float *M; /* alias of filter matrix */
|
|
double dval;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, src, dst, filtr);
|
|
#endif
|
|
|
|
if (src->type != FIMG_TYPE_RGB) {
|
|
fprintf(stderr, "%s: src type %d invalid\n", __func__, src->type);
|
|
return -99;
|
|
}
|
|
if (dst->type != FIMG_TYPE_RGB) {
|
|
fprintf(stderr, "%s: dst type %d invalid\n", __func__, dst->type);
|
|
return -99;
|
|
}
|
|
if (fimg_images_not_compatible(src, dst)) {
|
|
fprintf(stderr, "%s: src & dst not compatibles\n", __func__);
|
|
return -98;
|
|
}
|
|
|
|
if (verbosity > 1) {
|
|
fimg_show_filter((char *)__func__, filtr);
|
|
}
|
|
|
|
/* aliasing some vars for cleaner code */
|
|
pr = src->R; pg = src->G; pb = src->B;
|
|
w = src->width; h = src->height;
|
|
M = filtr->matrix;
|
|
|
|
for (y=1; y < h-1; y++) {
|
|
for (x=1; x < w-1; x++) {
|
|
of = x + (y * w);
|
|
|
|
dval = M[0] * pr[of-(w+1)] +
|
|
M[1] * pr[of-w] +
|
|
M[2] * pr[of-(w-1)] +
|
|
M[3] * pr[of-1] +
|
|
M[4] * pr[of] +
|
|
M[5] * pr[of+1] +
|
|
M[6] * pr[of+(w+1)] +
|
|
M[7] * pr[of+w] +
|
|
M[8] * pr[of+(w-1)] ;
|
|
|
|
dst->R[of] = dval + filtr->offset;
|
|
|
|
dval = M[0] * pg[of-(w+1)] +
|
|
M[1] * pg[of-w] +
|
|
M[2] * pg[of-(w-1)] +
|
|
M[3] * pg[of-1] +
|
|
M[4] * pg[of] +
|
|
M[5] * pg[of+1] +
|
|
M[6] * pg[of+(w+1)] +
|
|
M[7] * pg[of+w] +
|
|
M[8] * pg[of+(w-1)] ;
|
|
|
|
dst->G[of] = dval + filtr->offset;
|
|
|
|
dval = M[0] * pb[of-(w+1)] +
|
|
M[1] * pb[of-w] +
|
|
M[2] * pb[of-(w-1)] +
|
|
M[3] * pb[of-1] +
|
|
M[4] * pb[of] +
|
|
M[5] * pb[of+1] +
|
|
M[6] * pb[of+(w+1)] +
|
|
M[7] * pb[of+w] +
|
|
M[8] * pb[of+(w-1)] ;
|
|
|
|
dst->B[of] = dval + filtr->offset;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
/*
|
|
* this is the more shifting hack on the block.
|
|
*/
|
|
static int fimg_lissage_2x2_a(FloatImg *img)
|
|
{
|
|
int x, y, offset;
|
|
float cr, cg, cb;
|
|
float *pr, *pg, *pb;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
|
fprintf(stderr," type %d size %dx%d\n", img->type,
|
|
img->width, img->height);
|
|
#endif
|
|
|
|
if (img->type != FIMG_TYPE_RGB) {
|
|
fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
|
|
return -99;
|
|
}
|
|
|
|
pr = img->R; pg = img->G; pb = img->B;
|
|
|
|
for (y=1; y < img->height-1; y++) {
|
|
for (x=1; x < img->width-1; x++) {
|
|
offset = x + (y * img->width);
|
|
|
|
cr = pr[offset] + pr[offset+1] +
|
|
pr[offset+img->width] + pr[offset+img->width+1];
|
|
|
|
cg = pg[offset] + pg[offset+1] +
|
|
pg[offset+img->width] + pg[offset+img->width+1];
|
|
|
|
cb = pb[offset] + pb[offset+1] +
|
|
pb[offset+img->width] + pb[offset+img->width+1];
|
|
|
|
pr[offset] = cr / 4.0;
|
|
pg[offset] = cg / 4.0;
|
|
pb[offset] = cb / 4.0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
int fimg_killborders(FloatImg *img)
|
|
{
|
|
int idx, h, w, o;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
|
fprintf(stderr," type %d size %dx%d\n", img->type,
|
|
img->width, img->height);
|
|
#endif
|
|
|
|
if (img->type != FIMG_TYPE_RGB) {
|
|
fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
|
|
return -99;
|
|
}
|
|
|
|
h = img->height; w = img->width;
|
|
|
|
for (idx=0; idx<h; idx++) {
|
|
|
|
#define FAST 1
|
|
#if FAST
|
|
img->R[idx*w] = 0.0;
|
|
img->G[idx*w] = 0.0;
|
|
img->B[idx*w] = 0.0;
|
|
img->R[(idx*w)+w-1] = 0.0;
|
|
img->G[(idx*w)+w-1] = 0.0;
|
|
img->B[(idx*w)+w-1] = 0.0;
|
|
#else
|
|
fimg_plot_rgb(img, 0, idx, 0.0, 0.0, 0.0);
|
|
fimg_plot_rgb(img, w-1, idx, 0.0, 0.0, 0.0);
|
|
#endif
|
|
}
|
|
|
|
o = w * (h - 1);
|
|
for (idx=0; idx<w; idx++) {
|
|
#if FAST
|
|
img->R[idx] = 0.0;
|
|
img->G[idx] = 0.0;
|
|
img->B[idx] = 0.0;
|
|
img->R[idx+o] = 0.0;
|
|
img->G[idx+o] = 0.0;
|
|
img->B[idx+o] = 0.0;
|
|
#else
|
|
fimg_plot_rgb(img, idx, 0, 0.0, 0.0, 0.0);
|
|
fimg_plot_rgb(img, idx, h-1, 0.0, 0.0, 0.0);
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
int fimg_lissage_2x2(FloatImg *img)
|
|
{
|
|
int foo;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
|
#endif
|
|
|
|
foo = fimg_lissage_2x2_a(img);
|
|
if (foo) {
|
|
fprintf(stderr, "%s: fail %d\n", __func__, foo);
|
|
return foo;
|
|
}
|
|
|
|
fimg_killborders(img);
|
|
|
|
return foo;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------- */
|
|
/*
|
|
* XXX inplace filtering is a BAD IDEA
|
|
*/
|
|
int fimg_lissage_3x3(FloatImg *img)
|
|
{
|
|
int foo;
|
|
FloatImg tmp;
|
|
|
|
#if DEBUG_LEVEL
|
|
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
|
#endif
|
|
|
|
static FimgFilter3x3 lowpass = {
|
|
{
|
|
1.0, 2.0, 1.0,
|
|
2.0, 4.0, 2.0,
|
|
1.0, 2.0, 1.0,
|
|
},
|
|
16.0, 0.0
|
|
};
|
|
|
|
foo = fimg_clone(img, &tmp, 1);
|
|
if (foo) {
|
|
fprintf(stderr, "%s: clone -> %d\n", __func__, foo);
|
|
abort();
|
|
}
|
|
foo = fimg_filter_3x3(&tmp, img, &lowpass);
|
|
if (foo) {
|
|
fprintf(stderr, "%s: lowpass -> %d\n", __func__, foo);
|
|
abort();
|
|
}
|
|
|
|
foo = fimg_copy_data(&tmp, img);
|
|
if (foo) {
|
|
fprintf(stderr, "%s: copy data -> %d\n", __func__, foo);
|
|
abort();
|
|
}
|
|
|
|
foo = fimg_destroy(&tmp);
|
|
if (foo) {
|
|
fprintf(stderr, "%s: destroy -> %d\n", __func__, foo);
|
|
abort();
|
|
}
|
|
|
|
fimg_killborders(img);
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------- */
|
|
|