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.
191 lines
3.9 KiB
191 lines
3.9 KiB
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
#include <fcntl.h> |
|
#include <float.h> |
|
|
|
#include "../floatimg.h" |
|
|
|
/* -------------------------------------------------------------------- */ |
|
/* -------------------------------------------------------------------- */ |
|
/* -------------------------------------------------------------------- */ |
|
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 |
|
|
|
/* 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; |
|
|
|
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; |
|
|
|
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; |
|
} |
|
} |
|
|
|
return -1; |
|
} |
|
/* -------------------------------------------------------------------- */ |
|
/* |
|
* 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; |
|
|
|
foo = fimg_lissage_2x2_a(img); |
|
if (foo) { |
|
fprintf(stderr, "%s: fail %d\n", __func__, foo); |
|
return foo; |
|
} |
|
|
|
/* XXX */ |
|
fimg_killborders(img); |
|
|
|
return foo; |
|
} |
|
/* -------------------------------------------------------------------- */ |
|
|
|
|