source: libpipi/trunk/pipi/filter/transform.c @ 2902

Last change on this file since 2902 was 2902, checked in by Sam Hocevar, 11 years ago

Support C99 types on Win32 through the same hacks as in libcaca.

File size: 6.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 * transform.c: basic transformation functions
17 */
18
19#include "config.h"
20
21#include <stdlib.h>
22#include <stdio.h>
23#include <string.h>
24#include <math.h>
25
26#include "pipi.h"
27#include "pipi_internals.h"
28
29pipi_image_t *pipi_hflip(pipi_image_t *src)
30{
31    pipi_image_t *dst;
32    pipi_pixels_t *srcp, *dstp;
33    float *srcdata, *dstdata;
34    int x, y, w, h, gray;
35
36    w = src->w;
37    h = src->h;
38
39    gray = (src->last_modified == PIPI_PIXELS_Y_F);
40
41    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
42                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
43    srcdata = (float *)srcp->pixels;
44
45    dst = pipi_new(w, h);
46    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
47                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
48    dstdata = (float *)dstp->pixels;
49
50    for(y = 0; y < h; y++)
51    {
52        for(x = 0; x < w; x++)
53        {
54            if(gray)
55            {
56                dstdata[y * w + x] = srcdata[y * w + w - 1 - x];
57            }
58            else
59            {
60                dstdata[4 * (y * w + x)]
61                                = srcdata[4 * (y * w + w - 1 - x)];
62                dstdata[4 * (y * w + x) + 1]
63                                = srcdata[4 * (y * w + w - 1 - x) + 1];
64                dstdata[4 * (y * w + x) + 2]
65                                = srcdata[4 * (y * w + w - 1 - x) + 2];
66                dstdata[4 * (y * w + x) + 3]
67                                = srcdata[4 * (y * w + w - 1 - x) + 3];
68            }
69        }
70    }
71
72    return dst;
73}
74
75pipi_image_t *pipi_vflip(pipi_image_t *src)
76{
77    pipi_image_t *dst;
78    pipi_pixels_t *srcp, *dstp;
79    float *srcdata, *dstdata;
80    int y, w, h, gray;
81
82    w = src->w;
83    h = src->h;
84
85    gray = (src->last_modified == PIPI_PIXELS_Y_F);
86
87    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
88                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
89    srcdata = (float *)srcp->pixels;
90
91    dst = pipi_new(w, h);
92    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
93                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
94    dstdata = (float *)dstp->pixels;
95
96    for(y = 0; y < h; y++)
97    {
98        if(gray)
99        {
100            memcpy(dstdata + y * w,
101                   srcdata + (h - 1 - y) * w,
102                   w * sizeof(*dstdata));
103        }
104        else
105        {
106            memcpy(dstdata + 4 * y * w,
107                   srcdata + 4 * (h - 1 - y) * w,
108                   4 * w * sizeof(*dstdata));
109        }
110    }
111
112    return dst;
113}
114
115pipi_image_t *pipi_rotate90(pipi_image_t *src)
116{
117    pipi_image_t *dst;
118    pipi_pixels_t *srcp, *dstp;
119    float *srcdata, *dstdata;
120    int x, y, w, h, gray;
121
122    w = src->w;
123    h = src->h;
124
125    gray = (src->last_modified == PIPI_PIXELS_Y_F);
126
127    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
128                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
129    srcdata = (float *)srcp->pixels;
130
131    dst = pipi_new(h, w);
132    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
133                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
134    dstdata = (float *)dstp->pixels;
135
136    for(y = 0; y < h; y++)
137    {
138        for(x = 0; x < w; x++)
139        {
140            if(gray)
141            {
142                dstdata[x * h + y] = srcdata[y * w + w - 1 - x];
143            }
144            else
145            {
146                dstdata[4 * (x * h + y)]
147                    = srcdata[4 * (y * w + w - 1 - x)];
148                dstdata[4 * (x * h + y) + 1]
149                    = srcdata[4 * (y * w + w - 1 - x) + 1];
150                dstdata[4 * (x * h + y) + 2]
151                    = srcdata[4 * (y * w + w - 1 - x) + 2];
152                dstdata[4 * (x * h + y) + 3]
153                    = srcdata[4 * (y * w + w - 1 - x) + 3];
154            }
155        }
156    }
157
158    return dst;
159}
160
161pipi_image_t *pipi_rotate180(pipi_image_t *src)
162{
163    pipi_image_t *dst;
164    pipi_pixels_t *srcp, *dstp;
165    float *srcdata, *dstdata;
166    int x, y, w, h, gray;
167
168    w = src->w;
169    h = src->h;
170
171    gray = (src->last_modified == PIPI_PIXELS_Y_F);
172
173    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
174                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
175    srcdata = (float *)srcp->pixels;
176
177    dst = pipi_new(w, h);
178    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
179                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
180    dstdata = (float *)dstp->pixels;
181
182    for(y = 0; y < h; y++)
183    {
184        for(x = 0; x < w; x++)
185        {
186            if(gray)
187            {
188                dstdata[y * w + x] = srcdata[(h - 1 - y) * w + (w - 1 - x)];
189            }
190            else
191            {
192                dstdata[4 * (y * w + x)]
193                     = srcdata[4 * ((h - 1 - y) * w + (w - 1 - x))];
194                dstdata[4 * (y * w + x) + 1]
195                     = srcdata[4 * ((h - 1 - y) * w + (w - 1 - x)) + 1];
196                dstdata[4 * (y * w + x) + 2]
197                     = srcdata[4 * ((h - 1 - y) * w + (w - 1 - x)) + 2];
198                dstdata[4 * (y * w + x) + 3]
199                     = srcdata[4 * ((h - 1 - y) * w + (w - 1 - x)) + 3];
200            }
201        }
202    }
203
204    return dst;
205}
206
207pipi_image_t *pipi_rotate270(pipi_image_t *src)
208{
209    pipi_image_t *dst;
210    pipi_pixels_t *srcp, *dstp;
211    float *srcdata, *dstdata;
212    int x, y, w, h, gray;
213
214    w = src->w;
215    h = src->h;
216
217    gray = (src->last_modified == PIPI_PIXELS_Y_F);
218
219    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
220                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
221    srcdata = (float *)srcp->pixels;
222
223    dst = pipi_new(h, w);
224    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
225                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
226    dstdata = (float *)dstp->pixels;
227
228    for(y = 0; y < h; y++)
229    {
230        for(x = 0; x < w; x++)
231        {
232            if(gray)
233            {
234                dstdata[x * h + h - 1 - y] = srcdata[y * w + x];
235            }
236            else
237            {
238                dstdata[4 * (x * h + h - 1 - y)]
239                    = srcdata[4 * (y * w + x)];
240                dstdata[4 * (x * h + h - 1 - y) + 1]
241                    = srcdata[4 * (y * w + x) + 1];
242                dstdata[4 * (x * h + h - 1 - y) + 2]
243                    = srcdata[4 * (y * w + x) + 2];
244                dstdata[4 * (x * h + h - 1 - y) + 3]
245                    = srcdata[4 * (y * w + x) + 3];
246            }
247        }
248    }
249
250    return dst;
251}
252
Note: See TracBrowser for help on using the repository browser.