aboutsummaryrefslogtreecommitdiffstats
path: root/filter.c
diff options
context:
space:
mode:
Diffstat (limited to 'filter.c')
-rw-r--r--filter.c495
1 files changed, 495 insertions, 0 deletions
diff --git a/filter.c b/filter.c
new file mode 100644
index 0000000..283a1fa
--- /dev/null
+++ b/filter.c
@@ -0,0 +1,495 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include "readers.h"
+#include "filter.h"
+
+int debug = 0;
+
+/* ----------------------------------------------------------------------- */
+
+static void
+op_grayscale(struct ida_image *src, struct ida_rect *rect,
+ unsigned char *dst, int line, void *data)
+{
+ unsigned char *scanline;
+ int i,g;
+
+ scanline = src->data + line * src->i.width * 3;
+ memcpy(dst,scanline,src->i.width * 3);
+ if (line < rect->y1 || line >= rect->y2)
+ return;
+ dst += 3*rect->x1;
+ scanline += 3*rect->x1;
+ for (i = rect->x1; i < rect->x2; i++) {
+ g = (scanline[0]*30 + scanline[1]*59+scanline[2]*11)/100;
+ dst[0] = g;
+ dst[1] = g;
+ dst[2] = g;
+ scanline += 3;
+ dst += 3;
+ }
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct op_3x3_handle {
+ struct op_3x3_parm filter;
+ int *linebuf;
+};
+
+static void*
+op_3x3_init(struct ida_image *src, struct ida_rect *rect,
+ struct ida_image_info *i, void *parm)
+{
+ struct op_3x3_parm *args = parm;
+ struct op_3x3_handle *h;
+
+ h = malloc(sizeof(*h));
+ memcpy(&h->filter,args,sizeof(*args));
+ h->linebuf = malloc(sizeof(int)*3*(src->i.width));
+
+ *i = src->i;
+ return h;
+}
+
+static int inline
+op_3x3_calc_pixel(struct op_3x3_parm *p, unsigned char *s1,
+ unsigned char *s2, unsigned char *s3)
+{
+ int val = 0;
+
+ val += p->f1[0] * s1[0];
+ val += p->f1[1] * s1[3];
+ val += p->f1[2] * s1[6];
+ val += p->f2[0] * s2[0];
+ val += p->f2[1] * s2[3];
+ val += p->f2[2] * s2[6];
+ val += p->f3[0] * s3[0];
+ val += p->f3[1] * s3[3];
+ val += p->f3[2] * s3[6];
+ if (p->mul && p->div)
+ val = val * p->mul / p->div;
+ val += p->add;
+ return val;
+}
+
+static void
+op_3x3_calc_line(struct ida_image *src, struct ida_rect *rect,
+ int *dst, unsigned int line, struct op_3x3_parm *p)
+{
+ unsigned char b1[9],b2[9],b3[9];
+ unsigned char *s1,*s2,*s3;
+ unsigned int i,left,right;
+
+ s1 = src->data + (line-1) * src->i.width * 3;
+ s2 = src->data + line * src->i.width * 3;
+ s3 = src->data + (line+1) * src->i.width * 3;
+ if (0 == line)
+ s1 = src->data + line * src->i.width * 3;
+ if (src->i.height-1 == line)
+ s3 = src->data + line * src->i.width * 3;
+
+ left = rect->x1;
+ right = rect->x2;
+ if (0 == left) {
+ /* left border special case: dup first col */
+ memcpy(b1,s1,3);
+ memcpy(b2,s2,3);
+ memcpy(b3,s3,3);
+ memcpy(b1+3,s1,6);
+ memcpy(b2+3,s2,6);
+ memcpy(b3+3,s3,6);
+ dst[0] = op_3x3_calc_pixel(p,b1,b2,b3);
+ dst[1] = op_3x3_calc_pixel(p,b1+1,b2+1,b3+1);
+ dst[2] = op_3x3_calc_pixel(p,b1+2,b2+2,b3+2);
+ left++;
+ }
+ if (src->i.width == right) {
+ /* right border */
+ memcpy(b1,s1+src->i.width*3-6,6);
+ memcpy(b2,s2+src->i.width*3-6,6);
+ memcpy(b3,s3+src->i.width*3-6,6);
+ memcpy(b1+3,s1+src->i.width*3-3,3);
+ memcpy(b2+3,s2+src->i.width*3-3,3);
+ memcpy(b3+3,s3+src->i.width*3-3,3);
+ dst[src->i.width*3-3] = op_3x3_calc_pixel(p,b1,b2,b3);
+ dst[src->i.width*3-2] = op_3x3_calc_pixel(p,b1+1,b2+1,b3+1);
+ dst[src->i.width*3-1] = op_3x3_calc_pixel(p,b1+2,b2+2,b3+2);
+ right--;
+ }
+
+ dst += 3*left;
+ s1 += 3*(left-1);
+ s2 += 3*(left-1);
+ s3 += 3*(left-1);
+ for (i = left; i < right; i++) {
+ dst[0] = op_3x3_calc_pixel(p,s1++,s2++,s3++);
+ dst[1] = op_3x3_calc_pixel(p,s1++,s2++,s3++);
+ dst[2] = op_3x3_calc_pixel(p,s1++,s2++,s3++);
+ dst += 3;
+ }
+}
+
+static void
+op_3x3_clip_line(unsigned char *dst, int *src, int left, int right)
+{
+ int i,val;
+
+ src += left*3;
+ dst += left*3;
+ for (i = left*3; i < right*3; i++) {
+ val = *(src++);
+ if (val < 0)
+ val = 0;
+ if (val > 255)
+ val = 255;
+ *(dst++) = val;
+ }
+}
+
+static void
+op_3x3_work(struct ida_image *src, struct ida_rect *rect,
+ unsigned char *dst, int line, void *data)
+{
+ struct op_3x3_handle *h = data;
+ unsigned char *scanline;
+
+ scanline = src->data + line * src->i.width * 3;
+ memcpy(dst,scanline,src->i.width * 3);
+ if (line < rect->y1 || line >= rect->y2)
+ return;
+
+ op_3x3_calc_line(src,rect,h->linebuf,line,&h->filter);
+ op_3x3_clip_line(dst,h->linebuf,rect->x1,rect->x2);
+}
+
+static void
+op_3x3_free(void *data)
+{
+ struct op_3x3_handle *h = data;
+
+ free(h->linebuf);
+ free(h);
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct op_sharpe_handle {
+ int factor;
+ int *linebuf;
+};
+
+static void*
+op_sharpe_init(struct ida_image *src, struct ida_rect *rect,
+ struct ida_image_info *i, void *parm)
+{
+ struct op_sharpe_parm *args = parm;
+ struct op_sharpe_handle *h;
+
+ h = malloc(sizeof(*h));
+ h->factor = args->factor;
+ h->linebuf = malloc(sizeof(int)*3*(src->i.width));
+
+ *i = src->i;
+ return h;
+}
+
+static void
+op_sharpe_work(struct ida_image *src, struct ida_rect *rect,
+ unsigned char *dst, int line, void *data)
+{
+ static struct op_3x3_parm laplace = {
+ f1: { 1, 1, 1 },
+ f2: { 1, -8, 1 },
+ f3: { 1, 1, 1 },
+ };
+ struct op_sharpe_handle *h = data;
+ unsigned char *scanline;
+ int i;
+
+ scanline = src->data + line * src->i.width * 3;
+ memcpy(dst,scanline,src->i.width * 3);
+ if (line < rect->y1 || line >= rect->y2)
+ return;
+
+ op_3x3_calc_line(src,rect,h->linebuf,line,&laplace);
+ for (i = rect->x1*3; i < rect->x2*3; i++)
+ h->linebuf[i] = scanline[i] - h->linebuf[i] * h->factor / 256;
+ op_3x3_clip_line(dst,h->linebuf,rect->x1,rect->x2);
+}
+
+static void
+op_sharpe_free(void *data)
+{
+ struct op_sharpe_handle *h = data;
+
+ free(h->linebuf);
+ free(h);
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct op_resize_state {
+ float xscale,yscale,inleft;
+ float *rowbuf;
+ unsigned int width,height,srcrow;
+};
+
+static void*
+op_resize_init(struct ida_image *src, struct ida_rect *rect,
+ struct ida_image_info *i, void *parm)
+{
+ struct op_resize_parm *args = parm;
+ struct op_resize_state *h;
+
+ h = malloc(sizeof(*h));
+ h->width = args->width;
+ h->height = args->height;
+ h->xscale = (float)args->width/src->i.width;
+ h->yscale = (float)args->height/src->i.height;
+ h->rowbuf = malloc(src->i.width * 3 * sizeof(float));
+ h->srcrow = 0;
+ h->inleft = 1;
+
+ *i = src->i;
+ i->width = args->width;
+ i->height = args->height;
+ i->dpi = args->dpi;
+ return h;
+}
+
+static void
+op_resize_work(struct ida_image *src, struct ida_rect *rect,
+ unsigned char *dst, int line, void *data)
+{
+ struct op_resize_state *h = data;
+ float outleft,left,weight,d0,d1,d2;
+ unsigned char *csrcline;
+ float *fsrcline;
+ unsigned int i,sx,dx;
+
+ /* scale y */
+ memset(h->rowbuf, 0, src->i.width * 3 * sizeof(float));
+ outleft = 1/h->yscale;
+ while (outleft > 0 && h->srcrow < src->i.height) {
+ if (outleft < h->inleft) {
+ weight = outleft * h->yscale;
+ h->inleft -= outleft;
+ outleft = 0;
+ } else {
+ weight = h->inleft * h->yscale;
+ outleft -= h->inleft;
+ h->inleft = 0;
+ }
+#if 0
+ if (debug)
+ fprintf(stderr,"y: %6.2f%%: %d/%d => %d/%d\n",
+ weight*100,h->srcrow,src->height,line,h->height);
+#endif
+ csrcline = src->data + h->srcrow * src->i.width * 3;
+ for (i = 0; i < src->i.width * 3; i++)
+ h->rowbuf[i] += (float)csrcline[i] * weight;
+ if (0 == h->inleft) {
+ h->inleft = 1;
+ h->srcrow++;
+ }
+ }
+
+ /* scale x */
+ left = 1;
+ fsrcline = h->rowbuf;
+ for (sx = 0, dx = 0; dx < h->width; dx++) {
+ d0 = d1 = d2 = 0;
+ outleft = 1/h->xscale;
+ while (outleft > 0 && dx < h->width && sx < src->i.width) {
+ if (outleft < left) {
+ weight = outleft * h->xscale;
+ left -= outleft;
+ outleft = 0;
+ } else {
+ weight = left * h->xscale;
+ outleft -= left;
+ left = 0;
+ }
+#if 0
+ if (debug)
+ fprintf(stderr," x: %6.2f%%: %d/%d => %d/%d\n",
+ weight*100,sx,src->width,dx,h->width);
+#endif
+ d0 += fsrcline[3*sx+0] * weight;
+ d1 += fsrcline[3*sx+1] * weight;
+ d2 += fsrcline[3*sx+2] * weight;
+ if (0 == left) {
+ left = 1;
+ sx++;
+ }
+ }
+ dst[0] = d0;
+ dst[1] = d1;
+ dst[2] = d2;
+ dst += 3;
+ }
+}
+
+static void
+op_resize_done(void *data)
+{
+ struct op_resize_state *h = data;
+
+ free(h->rowbuf);
+ free(h);
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct op_rotate_state {
+ float angle,sina,cosa;
+ struct ida_rect calc;
+ int cx,cy;
+};
+
+static void*
+op_rotate_init(struct ida_image *src, struct ida_rect *rect,
+ struct ida_image_info *i, void *parm)
+{
+ struct op_rotate_parm *args = parm;
+ struct op_rotate_state *h;
+ float diag;
+
+ h = malloc(sizeof(*h));
+ h->angle = args->angle * 2 * M_PI / 360;
+ h->sina = sin(h->angle);
+ h->cosa = cos(h->angle);
+ h->cx = (rect->x2 - rect->x1) / 2 + rect->x1;
+ h->cy = (rect->y2 - rect->y1) / 2 + rect->y1;
+
+ /* the area we have to process (worst case: 45°) */
+ diag = sqrt((rect->x2 - rect->x1)*(rect->x2 - rect->x1) +
+ (rect->y2 - rect->y1)*(rect->y2 - rect->y1))/2;
+ h->calc.x1 = h->cx - diag;
+ h->calc.x2 = h->cx + diag;
+ h->calc.y1 = h->cy - diag;
+ h->calc.y2 = h->cy + diag;
+ if (h->calc.x1 < 0)
+ h->calc.x1 = 0;
+ if (h->calc.x2 > src->i.width)
+ h->calc.x2 = src->i.width;
+ if (h->calc.y1 < 0)
+ h->calc.y1 = 0;
+ if (h->calc.y2 > src->i.height)
+ h->calc.y2 = src->i.height;
+
+ *i = src->i;
+ return h;
+}
+
+static inline
+unsigned char* op_rotate_getpixel(struct ida_image *src, struct ida_rect *rect,
+ int sx, int sy, int dx, int dy)
+{
+ static unsigned char black[] = { 0, 0, 0};
+
+ if (sx < rect->x1 || sx >= rect->x2 ||
+ sy < rect->y1 || sy >= rect->y2) {
+ if (dx < rect->x1 || dx >= rect->x2 ||
+ dy < rect->y1 || dy >= rect->y2)
+ return src->data + dy * src->i.width * 3 + dx * 3;
+ return black;
+ }
+ return src->data + sy * src->i.width * 3 + sx * 3;
+}
+
+static void
+op_rotate_work(struct ida_image *src, struct ida_rect *rect,
+ unsigned char *dst, int y, void *data)
+{
+ struct op_rotate_state *h = data;
+ unsigned char *pix;
+ float fx,fy,w;
+ int x,sx,sy;
+
+ pix = src->data + y * src->i.width * 3;
+ memcpy(dst,pix,src->i.width * 3);
+ if (y < h->calc.y1 || y >= h->calc.y2)
+ return;
+
+ dst += 3*h->calc.x1;
+ memset(dst, 0, (h->calc.x2-h->calc.x1) * 3);
+ for (x = h->calc.x1; x < h->calc.x2; x++, dst+=3) {
+ fx = h->cosa * (x - h->cx) - h->sina * (y - h->cy) + h->cx;
+ fy = h->sina * (x - h->cx) + h->cosa * (y - h->cy) + h->cy;
+ sx = (int)fx;
+ sy = (int)fy;
+ if (fx < 0)
+ sx--;
+ if (fy < 0)
+ sy--;
+ fx -= sx;
+ fy -= sy;
+
+ pix = op_rotate_getpixel(src,rect,sx,sy,x,y);
+ w = (1-fx) * (1-fy);
+ dst[0] += pix[0] * w;
+ dst[1] += pix[1] * w;
+ dst[2] += pix[2] * w;
+ pix = op_rotate_getpixel(src,rect,sx+1,sy,x,y);
+ w = fx * (1-fy);
+ dst[0] += pix[0] * w;
+ dst[1] += pix[1] * w;
+ dst[2] += pix[2] * w;
+ pix = op_rotate_getpixel(src,rect,sx,sy+1,x,y);
+ w = (1-fx) * fy;
+ dst[0] += pix[0] * w;
+ dst[1] += pix[1] * w;
+ dst[2] += pix[2] * w;
+ pix = op_rotate_getpixel(src,rect,sx+1,sy+1,x,y);
+ w = fx * fy;
+ dst[0] += pix[0] * w;
+ dst[1] += pix[1] * w;
+ dst[2] += pix[2] * w;
+ }
+}
+
+static void
+op_rotate_done(void *data)
+{
+ struct op_rotate_state *h = data;
+
+ free(h);
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct ida_op desc_grayscale = {
+ name: "grayscale",
+ init: op_none_init,
+ work: op_grayscale,
+ done: op_none_done,
+};
+struct ida_op desc_3x3 = {
+ name: "3x3",
+ init: op_3x3_init,
+ work: op_3x3_work,
+ done: op_3x3_free,
+};
+struct ida_op desc_sharpe = {
+ name: "sharpe",
+ init: op_sharpe_init,
+ work: op_sharpe_work,
+ done: op_sharpe_free,
+};
+struct ida_op desc_resize = {
+ name: "resize",
+ init: op_resize_init,
+ work: op_resize_work,
+ done: op_resize_done,
+};
+struct ida_op desc_rotate = {
+ name: "rotate",
+ init: op_rotate_init,
+ work: op_rotate_work,
+ done: op_rotate_done,
+};
generated by cgit (git 2.34.1) at 2024-11-01 05:12:40 +0000