← Back to branch summary

~profzoom/ubuntu/quantal/wmaker/bug-1079925

« back to all changes in this revision

Viewing changes to wrlib/convolve.c

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo E. Magallon
  • Date: 2004-11-10 14:05:30 UTC
  • Revision ID: james.westby@ubuntu.com-20041110140530-qpd66b5lm38x7apk
Tags: upstream-0.91.0
Import upstream version 0.91.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
wrlib/convolve.c
 
1
/*
 
2
 * Raster graphics library
 
3
 *
 
4
 * Copyright (c) 1997-2003 Alfredo K. Kojima
 
5
 *
 
6
 *  This library is free software; you can redistribute it and/or
 
7
 *  modify it under the terms of the GNU Library General Public
 
8
 *  License as published by the Free Software Foundation; either
 
9
 *  version 2 of the License, or (at your option) any later version.
 
10
 *
 
11
 *  This library is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 *  Library General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU Library General Public
 
17
 *  License along with this library; if not, write to the Free
 
18
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 */
 
20
 
 
21
#include <config.h>
 
22
 
 
23
 
 
24
#include <stdlib.h>
 
25
#include <stdio.h>
 
26
#include <string.h>
 
27
#include <X11/Xlib.h>
 
28
#include "wraster.h"
 
29
 
 
30
 
 
31
/*
 
32
 *----------------------------------------------------------------------
 
33
 * RBlurImage--
 
34
 *      Apply 3x3 1 1 1 low pass, convolution mask to image.
 
35
 *                1 2 1
 
36
 *                1 1 1 /10
 
37
 *----------------------------------------------------------------------
 
38
 */
 
39
int
 
40
RBlurImage(RImage *image)
 
41
{
 
42
    register int x, y;
 
43
    register int tmp;
 
44
    unsigned char *ptr, *nptr;
 
45
    unsigned char *pptr=NULL, *tmpp;
 
46
    int ch = image->format == RRGBAFormat ? 4 : 3;
 
47
 
 
48
    pptr = malloc(image->width * ch);
 
49
    if (!pptr) {
 
50
        RErrorCode = RERR_NOMEMORY;
 
51
        return False;
 
52
    }
 
53
 
 
54
#define MASK(prev, cur, next, ch)\
 
55
    (*(prev-ch) + *prev + *(prev+ch)\
 
56
    +*(cur-ch) + 2 * *cur + *(cur+ch)\
 
57
    +*(next-ch) + *next + *(next+ch)) / 10
 
58
 
 
59
    memcpy(pptr, image->data, image->width * ch);
 
60
 
 
61
    ptr = image->data;
 
62
    nptr = ptr + image->width*ch;
 
63
    tmpp = pptr;
 
64
 
 
65
    if (ch == 3) {
 
66
        ptr+=3;
 
67
        nptr+=3;
 
68
        pptr+=3;
 
69
 
 
70
        for (y = 1; y < image->height-1; y++) {
 
71
 
 
72
            for (x = 1; x < image->width-1; x++) {
 
73
                tmp = *ptr;
 
74
                *ptr = MASK(pptr, ptr, nptr, 3);
 
75
                *pptr = tmp;
 
76
                ptr++; nptr++; pptr++;
 
77
 
 
78
                tmp = *ptr;
 
79
                *ptr = MASK(pptr, ptr, nptr, 3);
 
80
                *pptr = tmp;
 
81
                ptr++; nptr++; pptr++;
 
82
 
 
83
                tmp = *ptr;
 
84
                *ptr = MASK(pptr, ptr, nptr, 3);
 
85
                *pptr = tmp;
 
86
                ptr++; nptr++; pptr++;
 
87
            }
 
88
            pptr = tmpp;
 
89
            ptr+=6;
 
90
            nptr+=6;
 
91
            pptr+=6;
 
92
        }
 
93
    } else {
 
94
        ptr+=4;
 
95
        nptr+=4;
 
96
        pptr+=4;
 
97
 
 
98
        for (y = 1; y < image->height-1; y++) {
 
99
            for (x = 1; x < image->width-1; x++) {
 
100
                tmp = *ptr;
 
101
                *ptr = MASK(pptr, ptr, nptr, 4);
 
102
                *pptr = tmp;
 
103
                ptr++; nptr++; pptr++;
 
104
 
 
105
                tmp = *ptr;
 
106
                *ptr = MASK(pptr, ptr, nptr, 4);
 
107
                *pptr = tmp;
 
108
                ptr++; nptr++; pptr++;
 
109
 
 
110
                tmp = *ptr;
 
111
                *ptr = MASK(pptr, ptr, nptr, 4);
 
112
                *pptr = tmp;
 
113
                ptr++; nptr++; pptr++;
 
114
 
 
115
                tmp = *ptr;
 
116
                *ptr = MASK(pptr, ptr, nptr, 4);
 
117
                *pptr = tmp;
 
118
                ptr++; nptr++; pptr++;
 
119
            }
 
120
            pptr = tmpp;
 
121
            ptr+=8;
 
122
            nptr+=8;
 
123
            pptr+=8;
 
124
        }
 
125
    }
 
126
 
 
127
 
 
128
    return True;
 
129
}
 
130
 
 
131
 
 
132
#if 0
 
133
int
 
134
REdgeDetectImage(RImage *image)
 
135
{
 
136
    register int x, y, d1, d2, d3, d4, rsum;
 
137
    int w;
 
138
    unsigned char *r, *g, *b, *a;
 
139
    unsigned char *dr, *dg, *db, *da;
 
140
    unsigned char *pr=NULL, *pg=NULL, *pb=NULL, *pa=NULL;
 
141
    RImage *image2;
 
142
 
 
143
 
 
144
    image2 = RCloneImage(image);
 
145
 
 
146
    pr = alloca(image->width*sizeof(char));
 
147
    if (!pr)
 
148
        goto outofmem;
 
149
 
 
150
    pg = alloca(image->width*sizeof(char));
 
151
    if (!pg)
 
152
        goto outofmem;
 
153
 
 
154
    pb = alloca(image->width*sizeof(char));
 
155
    if (!pb)
 
156
        goto outofmem;
 
157
 
 
158
    pa = alloca(image->width*sizeof(char));
 
159
    if (!pa)
 
160
        goto outofmem;
 
161
 
 
162
 
 
163
    r = image->data[0];
 
164
    g = image->data[1];
 
165
    b = image->data[2];
 
166
    a = image->data[3];
 
167
 
 
168
    dr = image2->data[0];
 
169
    dg = image2->data[1];
 
170
    db = image2->data[2];
 
171
    da = image2->data[3];
 
172
 
 
173
 
 
174
    for (x=0; x<image->width; x++) {
 
175
        *(dr++) = *(r++);
 
176
        *(dg++) = *(g++);
 
177
        *(db++) = *(b++);
 
178
    }
 
179
 
 
180
    w = image->width;
 
181
 
 
182
    for (y=1; y<image->height-1; y++) {
 
183
        dr[w-1] = r[w-1];
 
184
        dg[w-1] = g[w-1];
 
185
        db[w-1] = b[w-1];
 
186
 
 
187
        *(dr++) = *(r++);
 
188
        *(dg++) = *(g++);
 
189
        *(db++) = *(b++);
 
190
 
 
191
        for (x=1; x<image->width-1; x++) {
 
192
            d1 = r[w+1]  - r[-w-1];
 
193
            d2 = r[1]    - r[-1];
 
194
            d3 = r[-w+1] - r[w-1];
 
195
            d4 = r[-w]   - r[w];
 
196
 
 
197
            rsum = d1 + d2 + d3;
 
198
            if (rsum < 0) rsum = -rsum;
 
199
            d1 = d1 - d2 - d4;         /* vertical gradient */
 
200
            if (d1 < 0) d1 = -d1;
 
201
            if (d1 > rsum) rsum = d1;
 
202
            rsum /= 3;
 
203
 
 
204
            *(dr++) = rsum;
 
205
 
 
206
            d1 = g[w+1]  - g[-w-1];
 
207
            d2 = g[1]    - g[-1];
 
208
            d3 = g[-w+1] - g[w-1];
 
209
            d4 = g[-w]   - g[w];
 
210
 
 
211
            rsum = d1 + d2 + d3;
 
212
            if (rsum < 0) rsum = -rsum;
 
213
            d1 = d1 - d2 - d4;         /* vertical gradient */
 
214
            if (d1 < 0) d1 = -d1;
 
215
            if (d1 > rsum) rsum = d1;
 
216
            rsum /= 3;
 
217
 
 
218
            *(dg++) = rsum;
 
219
 
 
220
            d1 = b[w+1]  - b[-w-1];
 
221
            d2 = b[1]    - b[-1];
 
222
            d3 = b[-w+1] - b[w-1];
 
223
            d4 = b[-w]   - b[w];
 
224
 
 
225
            rsum = d1 + d2 + d3;
 
226
            if (rsum < 0) rsum = -rsum;
 
227
            d1 = d1 - d2 - d4;         /* vertical gradient */
 
228
            if (d1 < 0) d1 = -d1;
 
229
            if (d1 > rsum) rsum = d1;
 
230
            rsum /= 3;
 
231
 
 
232
            *(db++) = rsum;
 
233
 
 
234
            r++;
 
235
            g++;
 
236
            b++;
 
237
        }
 
238
        r++;
 
239
        g++;
 
240
        b++;
 
241
 
 
242
        dr++;
 
243
        dg++;
 
244
        db++;
 
245
    }
 
246
    {
 
247
        r = image->data[0];
 
248
        image2->data[0] = r;
 
249
        g = image->data[1];
 
250
        image2->data[1] = g;
 
251
        b = image->data[2];
 
252
        image2->data[2] = b;
 
253
        RReleaseImage(image2);
 
254
    }
 
255
 
 
256
#undef MASK
 
257
 
 
258
    return True;
 
259
}
 
260
 
 
261
 
 
262
int
 
263
RSmoothImage(RImage *image)
 
264
{
 
265
    register int x, y;
 
266
    register int v, w;
 
267
    unsigned char *ptr;
 
268
    int ch = image->format == RRGBAFormat;
 
269
 
 
270
    ptr = image->data;
 
271
 
 
272
 
 
273
    w = image->width*ch;
 
274
    for (y=0; y<image->height - 1; y++) {
 
275
        for (x=0; x<image->width - 1; x++) {
 
276
            v = *ptr + 2 * *(ptr + ch) + 2 * *(ptr + w) + *(ptr + w + ch);
 
277
            *ptr = v/6;
 
278
            v = *(ptr+1) + 2 * *(ptr+1 + ch) + 2 * *(ptr+1 + w) + *(ptr+1 + w + ch);
 
279
            *(ptr+1) = v/6;
 
280
            v = *(ptr+2) + 2 * *(ptr+2 + ch) + 2 * *(ptr+2 + w) + *(ptr+2 + w + ch);
 
281
            *(ptr+2) = v/6;
 
282
 
 
283
            ptr+= ch;
 
284
        }
 
285
        /* last column */
 
286
        v = 3 * *ptr + 3 * *(ptr + w);
 
287
        *ptr = v/6;
 
288
        v = 3 * *(ptr+1) + 3 * *(ptr+1 + w);
 
289
        *(ptr+1) = v/6;
 
290
        v = 3 * *(ptr+2) + 3 * *(ptr+2 + w);
 
291
        *(ptr+2) = v/6;
 
292
 
 
293
        ptr+= ch;
 
294
    }
 
295
 
 
296
    /* last line */
 
297
    for (x=0; x<image->width - 1; x++) {
 
298
        v = 3 * *ptr + 3 * *(ptr + ch);
 
299
        *ptr = v/6;
 
300
        v = 3 * *(ptr+1) + 3 * *(ptr+1 + ch);
 
301
        *(ptr+1) = v/6;
 
302
        v = 3 * *(ptr+2) + 3 * *(ptr+2 + ch);
 
303
        *(ptr+2) = v/6;
 
304
 
 
305
        ptr+= ch;
 
306
    }
 
307
 
 
308
    return True;
 
309
}
 
310
#endif
 
311