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

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

Change _C pixel format suffixes into _U8 for more clarity.

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_F32);
40
41    srcp = gray ? pipi_get_pixels(src, PIPI_PIXELS_Y_F32)
42                : pipi_get_pixels(src, PIPI_PIXELS_RGBA_F32);
43    srcdata = (float *)srcp->pixels;
44
45    dst = pipi_new(w, h);
46    dstp = gray ? pipi_get_pixels(dst, PIPI_PIXELS_Y_F32)
47                : pipi_get_pixels(dst, PIPI_PIXELS_RGBA_F32);
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_F32);
86
87    srcp = gray ? pipi_get_pixels(src, PIPI_PIXELS_Y_F32)
88                : pipi_get_pixels(src, PIPI_PIXELS_RGBA_F32);
89    srcdata = (float *)srcp->pixels;
90
91    dst = pipi_new(w, h);
92    dstp = gray ? pipi_get_pixels(dst, PIPI_PIXELS_Y_F32)
93                : pipi_get_pixels(dst, PIPI_PIXELS_RGBA_F32);
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_F32);
126
127    srcp = gray ? pipi_get_pixels(src, PIPI_PIXELS_Y_F32)
128                : pipi_get_pixels(src, PIPI_PIXELS_RGBA_F32);
129    srcdata = (float *)srcp->pixels;
130
131    dst = pipi_new(h, w);
132    dstp = gray ? pipi_get_pixels(dst, PIPI_PIXELS_Y_F32)
133                : pipi_get_pixels(dst, PIPI_PIXELS_RGBA_F32);
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_F32);
172
173    srcp = gray ? pipi_get_pixels(src, PIPI_PIXELS_Y_F32)
174                : pipi_get_pixels(src, PIPI_PIXELS_RGBA_F32);
175    srcdata = (float *)srcp->pixels;
176
177    dst = pipi_new(w, h);
178    dstp = gray ? pipi_get_pixels(dst, PIPI_PIXELS_Y_F32)
179                : pipi_get_pixels(dst, PIPI_PIXELS_RGBA_F32);
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_F32);
218
219    srcp = gray ? pipi_get_pixels(src, PIPI_PIXELS_Y_F32)
220                : pipi_get_pixels(src, PIPI_PIXELS_RGBA_F32);
221    srcdata = (float *)srcp->pixels;
222
223    dst = pipi_new(h, w);
224    dstp = gray ? pipi_get_pixels(dst, PIPI_PIXELS_Y_F32)
225                : pipi_get_pixels(dst, PIPI_PIXELS_RGBA_F32);
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.