source: libpipi/trunk/pipi/filter/color.c @ 2844

Last change on this file since 2844 was 2844, checked in by Sam Hocevar, 12 years ago

Fix headers.

File size: 7.7 KB
Line 
1/*
2 *  libpipi       Pathetic image processing interface 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 * color.c: colour manipulation 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
30pipi_image_t *pipi_brightness(pipi_image_t *src, double val)
31{
32    pipi_image_t *dst;
33    pipi_pixels_t *srcp, *dstp;
34    float *srcdata, *dstdata;
35    int x, y, w, h, gray;
36
37    w = src->w;
38    h = src->h;
39
40    gray = (src->last_modified == PIPI_PIXELS_Y_F);
41
42    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
43                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
44    srcdata = (float *)srcp->pixels;
45
46    dst = pipi_new(w, h);
47    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
48                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
49    dstdata = (float *)dstp->pixels;
50
51    if(val >= 0.0)
52    {
53        for(y = 0; y < h; y++)
54        {
55            for(x = 0; x < w; x++)
56            {
57                if(gray)
58                {
59                    double p = srcdata[y * w + x];
60                    dstdata[y * w + x] = p < 1. - val ? p + val : 1.;
61                }
62                else
63                {
64                    double p;
65                    int d = 4 * (y * w + x);
66
67                    p = srcdata[d];
68                    dstdata[d] = p < 1. - val ? p + val : 1.;
69                    p = srcdata[d + 1];
70                    dstdata[d + 1] = p < 1. - val ? p + val : 1.;
71                    p = srcdata[d + 2];
72                    dstdata[d + 2] = p < 1. - val ? p + val : 1.;
73                    p = srcdata[d + 3];
74                    dstdata[d + 3] = p < 1. - val ? p + val : 1.;
75                }
76            }
77        }
78    }
79    else
80    {
81        for(y = 0; y < h; y++)
82        {
83            for(x = 0; x < w; x++)
84            {
85                if(gray)
86                {
87                    double p = srcdata[y * w + x];
88                    dstdata[y * w + x] = p > -val ? p + val : 0.;
89                }
90                else
91                {
92                    double p;
93                    int d = 4 * (y * w + x);
94
95                    p = srcdata[d];
96                    dstdata[d] = p > -val ? p + val : 0.;
97                    p = srcdata[d + 1];
98                    dstdata[d + 1] = p > -val ? p + val : 0.;
99                    p = srcdata[d + 2];
100                    dstdata[d + 2] = p > -val ? p + val : 0.;
101                    p = srcdata[d + 3];
102                    dstdata[d + 3] = p > -val ? p + val : 0.;
103                }
104            }
105        }
106    }
107
108    return dst;
109}
110
111pipi_image_t *pipi_contrast(pipi_image_t *src, double val)
112{
113    pipi_image_t *dst;
114    pipi_pixels_t *srcp, *dstp;
115    float *srcdata, *dstdata;
116    int x, y, w, h, gray;
117
118    w = src->w;
119    h = src->h;
120
121    gray = (src->last_modified == PIPI_PIXELS_Y_F);
122
123    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
124                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
125    srcdata = (float *)srcp->pixels;
126
127    dst = pipi_new(w, h);
128    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
129                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
130    dstdata = (float *)dstp->pixels;
131
132    if(val >= 0.0)
133    {
134        if(val > 0.99999)
135            val = 0.99999;
136
137        val = 1. / (1. - val);
138
139        for(y = 0; y < h; y++)
140        {
141            for(x = 0; x < w; x++)
142            {
143                if(gray)
144                {
145                    double p = (srcdata[y * w + x] - 0.5) * val + 0.5;
146                    dstdata[y * w + x] = p < 0. ? 0. : p > 1. ? 1. : p;
147                }
148                else
149                {
150                    double p;
151                    int d = 4 * (y * w + x);
152
153                    p = (srcdata[d] - 0.5) * val + 0.5;
154                    dstdata[d] = p < 0. ? 0. : p > 1. ? 1. : p;
155                    p = (srcdata[d + 1] - 0.5) * val + 0.5;
156                    dstdata[d + 1] = p < 0. ? 0. : p > 1. ? 1. : p;
157                    p = (srcdata[d + 2] - 0.5) * val + 0.5;
158                    dstdata[d + 2] = p < 0. ? 0. : p > 1. ? 1. : p;
159                    p = (srcdata[d + 3] - 0.5) * val + 0.5;
160                    dstdata[d + 3] = p < 0. ? 0. : p > 1. ? 1. : p;
161                }
162            }
163        }
164    }
165    else
166    {
167        if(val < -1.)
168            val = -1.;
169
170        val = 1. + val;
171
172        for(y = 0; y < h; y++)
173        {
174            for(x = 0; x < w; x++)
175            {
176                if(gray)
177                {
178                    double p = srcdata[y * w + x];
179                    dstdata[y * w + x] = (p - 0.5) * val + 0.5;
180                }
181                else
182                {
183                    double p;
184                    int d = 4 * (y * w + x);
185
186                    p = srcdata[d];
187                    dstdata[d] = (p - 0.5) * val + 0.5;
188                    p = srcdata[d + 1];
189                    dstdata[d + 1] = (p - 0.5) * val + 0.5;
190                    p = srcdata[d + 2];
191                    dstdata[d + 2] = (p - 0.5) * val + 0.5;
192                    p = srcdata[d + 3];
193                    dstdata[d + 3] = (p - 0.5) * val + 0.5;
194                }
195            }
196        }
197    }
198
199    return dst;
200}
201
202pipi_image_t *pipi_invert(pipi_image_t *src)
203{
204    pipi_image_t *dst;
205    pipi_pixels_t *srcp, *dstp;
206    float *srcdata, *dstdata;
207    int x, y, w, h, gray;
208
209    w = src->w;
210    h = src->h;
211
212    gray = (src->last_modified == PIPI_PIXELS_Y_F);
213
214    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
215                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
216    srcdata = (float *)srcp->pixels;
217
218    dst = pipi_new(w, h);
219    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
220                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
221    dstdata = (float *)dstp->pixels;
222
223    for(y = 0; y < h; y++)
224    {
225        for(x = 0; x < w; x++)
226        {
227            if(gray)
228            {
229                dstdata[y * w + x] = 1. - srcdata[y * w + x];
230            }
231            else
232            {
233                int d = 4 * (y * w + x);
234
235                dstdata[d] = 1. - srcdata[d];
236                dstdata[d + 1] = 1. - srcdata[d + 1];
237                dstdata[d + 2] = 1. - srcdata[d + 2];
238                dstdata[d + 3] = 1. - srcdata[d + 3];
239            }
240        }
241    }
242
243    return dst;
244}
245
246pipi_image_t *pipi_threshold(pipi_image_t *src, double val)
247{
248    pipi_image_t *dst;
249    pipi_pixels_t *srcp, *dstp;
250    float *srcdata, *dstdata;
251    int x, y, w, h, gray;
252
253    w = src->w;
254    h = src->h;
255
256    gray = (src->last_modified == PIPI_PIXELS_Y_F);
257
258    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
259                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
260    srcdata = (float *)srcp->pixels;
261
262    dst = pipi_new(w, h);
263    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
264                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
265    dstdata = (float *)dstp->pixels;
266
267    for(y = 0; y < h; y++)
268    {
269        for(x = 0; x < w; x++)
270        {
271            if(gray)
272            {
273                dstdata[y * w + x] = srcdata[y * w + x] < val ? 0. : 1.;
274            }
275            else
276            {
277                int d = 4 * (y * w + x);
278
279                dstdata[d] = srcdata[d] < val ? 0. : 1.;
280                dstdata[d + 1] = srcdata[d + 1] < val ? 0. : 1.;
281                dstdata[d + 2] = srcdata[d + 2] < val ? 0. : 1.;
282                dstdata[d + 3] = srcdata[d + 3] < val ? 0. : 1.;
283            }
284        }
285    }
286
287    return dst;
288}
289
Note: See TracBrowser for help on using the repository browser.