source: libpipi/trunk/pipi/filter/blur.c @ 2634

Last change on this file since 2634 was 2634, checked in by Sam Hocevar, 14 years ago
  • blur.c: support for greyscale images.
File size: 5.0 KB
Line 
1/*
2 *  libpipi       Proper image processing implementation library
3 *  Copyright (c) 2004-2008 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id$
7 *
8 *  This library is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 * blur.c: blur functions
17 */
18
19#include "config.h"
20#include "common.h"
21
22#include <stdlib.h>
23#include <stdio.h>
24#include <string.h>
25#include <math.h>
26
27#include "pipi.h"
28#include "pipi_internals.h"
29
30/* Any standard deviation below this value will be rounded up, in order
31 * to avoid ridiculously low values. exp(-1/(2*0.2*0.2)) is < 10^-5 so
32 * there is little chance that any value below 0.2 will be useful. */
33#define BLUR_EPSILON 0.2
34
35pipi_image_t *pipi_gaussian_blur(pipi_image_t *src, float radius)
36{
37    return pipi_gaussian_blur_ext(src, radius, radius, 0.0, 0.0);
38}
39
40pipi_image_t *pipi_gaussian_blur_ext(pipi_image_t *src, float rx, float ry,
41                                     float dx, float dy)
42{
43    pipi_image_t *dst;
44    pipi_pixels_t *srcp, *dstp;
45    float *srcdata, *dstdata;
46    double *kernel, *buffer;
47    double K;
48    int x, y, i, w, h, kr, kw, gray;
49
50    if(rx < BLUR_EPSILON) rx = BLUR_EPSILON;
51    if(ry < BLUR_EPSILON) ry = BLUR_EPSILON;
52
53    w = src->w;
54    h = src->h;
55
56    gray = (src->last_modified == PIPI_PIXELS_Y_F);
57
58    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
59                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
60    srcdata = (float *)srcp->pixels;
61
62    dst = pipi_new(w, h);
63    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
64                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
65    dstdata = (float *)dstp->pixels;
66
67    buffer = malloc(w * h * (gray ? 1 : 4) * sizeof(double));
68
69    kr = (int)(3. * rx + 1.99999);
70    kw = 2 * kr + 1;
71    K = -1. / (2. * rx * rx);
72
73    kernel = malloc(kw * sizeof(double));
74    for(i = -kr; i <= kr; i++)
75        kernel[i + kr] = exp(K * ((double)i - dx) * ((double)i - dx));
76
77    for(y = 0; y < h; y++)
78    {
79        for(x = 0; x < w; x++)
80        {
81            if(gray)
82            {
83                double Y = 0., t = 0.;
84                int x2;
85
86                for(i = -kr; i <= kr; i++)
87                {
88                    double f = kernel[i + kr];
89
90                    x2 = x + i;
91                    if(x2 < 0) x2 = 0;
92                    else if(x2 >= w) x2 = w - 1;
93
94                    Y += f * srcdata[y * w + x2];
95                    t += f;
96                }
97
98                buffer[y * w + x] = Y / t;
99            }
100            else
101            {
102                double R = 0., G = 0., B = 0., t = 0.;
103                int x2, off = 4 * (y * w + x);
104
105                for(i = -kr; i <= kr; i++)
106                {
107                    double f = kernel[i + kr];
108
109                    x2 = x + i;
110                    if(x2 < 0) x2 = 0;
111                    else if(x2 >= w) x2 = w - 1;
112
113                    R += f * srcdata[(y * w + x2) * 4];
114                    G += f * srcdata[(y * w + x2) * 4 + 1];
115                    B += f * srcdata[(y * w + x2) * 4 + 2];
116                    t += f;
117                }
118
119                buffer[off] = R / t;
120                buffer[off + 1] = G / t;
121                buffer[off + 2] = B / t;
122            }
123        }
124    }
125
126    free(kernel);
127
128    kr = (int)(3. * ry + 1.99999);
129    kw = 2 * kr + 1;
130    K = -1. / (2. * ry * ry);
131
132    kernel = malloc(kw * sizeof(double));
133    for(i = -kr; i <= kr; i++)
134        kernel[i + kr] = exp(K * ((double)i - dy) * ((double)i - dy));
135
136    for(y = 0; y < h; y++)
137    {
138        for(x = 0; x < w; x++)
139        {
140            if(gray)
141            {
142                double Y = 0., t = 0.;
143                int y2;
144
145                for(i = -kr; i <= kr; i++)
146                {
147                    double f = kernel[i + kr];
148
149                    y2 = y + i;
150                    if(y2 < 0) y2 = 0;
151                    else if(y2 >= h) y2 = h - 1;
152
153                    Y += f * buffer[y2 * w + x];
154                    t += f;
155                }
156
157                dstdata[y * w + x] = Y / t;
158            }
159            else
160            {
161                double R = 0., G = 0., B = 0., t = 0.;
162                int y2, off = 4 * (y * w + x);
163
164                for(i = -kr; i <= kr; i++)
165                {
166                    double f = kernel[i + kr];
167
168                    y2 = y + i;
169                    if(y2 < 0) y2 = 0;
170                    else if(y2 >= h) y2 = h - 1;
171
172                    R += f * buffer[(y2 * w + x) * 4];
173                    G += f * buffer[(y2 * w + x) * 4 + 1];
174                    B += f * buffer[(y2 * w + x) * 4 + 2];
175                    t += f;
176                }
177
178                dstdata[off] = R / t;
179                dstdata[off + 1] = G / t;
180                dstdata[off + 2] = B / t;
181            }
182        }
183    }
184
185    free(buffer);
186    free(kernel);
187
188    return dst;
189}
190
Note: See TracBrowser for help on using the repository browser.