1//
2//  PRTransforms.m
3//  PRICE
4//
5//  Created by Riccardo Mottola on Mon Dec 23 2002.
6//  Copyright (c) 2002-2014 Carduus. All rights reserved.
7//
8// This application is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
9// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
10
11#import "PRTransforms.h"
12#import "PRCProgress.h"
13
14@implementation PRTransforms
15
16- (PRImage *)filterImage:(PRImage *)image with:(NSArray *)parameters progressPanel:(PRCProgress *)progressPanel
17{
18    PRImage *retImage;
19
20    switch ([[parameters objectAtIndex:0] intValue])
21    {
22        case TRANSPOSE:
23            retImage = [self transposeImage:image];
24            break;
25        case ROTATE90:
26            retImage = [self rotateImage90:image];
27            break;
28        case ROTATE180:
29            retImage = [self rotateImage180:image];
30            break;
31        case ROTATE270:
32            retImage = [self rotateImage270:image];
33            break;
34        case FLIP_VERT:
35            retImage = [self flipImageVert:image];
36            break;
37        case FLIP_HORIZ:
38            retImage = [self flipImageHoriz:image];
39            break;
40        default:
41            retImage = nil;
42    }
43    return retImage;
44}
45
46- (void)setActionName:(NSString *)name
47{
48    actionName = name;
49}
50
51- (NSString *)actionName
52{
53    return actionName;
54}
55
56- (PRImage *)transposeImage:(PRImage *)srcImage
57{
58    NSBitmapImageRep *srcImageRep;
59    PRImage *destImage;
60    NSBitmapImageRep *destImageRep;
61    NSInteger w, h;
62    NSInteger x, y;
63    int s; /* sample */
64    unsigned char *srcData;
65    unsigned char *destData;
66    unsigned char *p1, *p2;
67    NSInteger srcSamplesPerPixel;
68    NSInteger destSamplesPerPixel;
69    register NSInteger srcBytesPerPixel;
70    register NSInteger destBytesPerPixel;
71    register NSInteger srcBytesPerRow;
72    register NSInteger destBytesPerRow;
73
74    /* get source image representation and associated information */
75    srcImageRep = [srcImage bitmapRep];
76
77    w = [srcImageRep pixelsWide];
78    h = [srcImageRep pixelsHigh];
79    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
80    destSamplesPerPixel = srcSamplesPerPixel;
81    srcBytesPerRow = [srcImageRep bytesPerRow];
82    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
83
84    /* execute the actual transposition */
85    /* allocate destination image and its representation */
86    destImage = [[PRImage alloc] initWithSize:NSMakeSize(h, w)]; /* we swap h and w */
87    destImageRep = [[NSBitmapImageRep alloc]
88            initWithBitmapDataPlanes:NULL
89                          pixelsWide:h
90                          pixelsHigh:w
91                       bitsPerSample:[srcImageRep bitsPerSample]
92                     samplesPerPixel:destSamplesPerPixel
93                            hasAlpha:[srcImageRep hasAlpha]
94                            isPlanar:NO
95                      colorSpaceName:[srcImageRep colorSpaceName]
96                         bytesPerRow:0
97                        bitsPerPixel:0];
98
99    srcData = [srcImageRep bitmapData];
100    destData = [destImageRep bitmapData];
101    destBytesPerRow = [destImageRep bytesPerRow];
102    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
103
104    for (y = 0; y < h; y++)
105        for (x = 0; x < w; x++)
106        {
107            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
108            p2 = destData + destBytesPerPixel *  y + destBytesPerRow * x;
109            for (s = 0; s < srcSamplesPerPixel; s++)
110                p2[s] = p1[s];
111        }
112
113    [destImage setBitmapRep:destImageRep];
114    [destImageRep release];
115    [destImage autorelease];
116    return destImage;
117}
118
119
120- (PRImage *)rotateImage90:(PRImage *)srcImage
121{
122    NSBitmapImageRep *srcImageRep;
123    PRImage *destImage;
124    NSBitmapImageRep *destImageRep;
125    NSInteger          w, h;
126    NSInteger          x, y;
127    int s; /* sample */
128    unsigned char *srcData;
129    unsigned char *destData;
130    unsigned char *p1, *p2;
131    NSInteger          srcSamplesPerPixel;
132    NSInteger          destSamplesPerPixel;
133    register NSInteger srcBytesPerPixel;
134    register NSInteger destBytesPerPixel;
135    register NSInteger srcBytesPerRow;
136    register NSInteger destBytesPerRow;
137
138
139    /* get source image representation and associated information */
140    srcImageRep = [srcImage bitmapRep];
141
142    w = [srcImageRep pixelsWide];
143    h = [srcImageRep pixelsHigh];
144    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
145    destSamplesPerPixel = srcSamplesPerPixel;
146    srcBytesPerRow = [srcImageRep bytesPerRow];
147    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
148
149    /* execute the actual rotation */
150    /* allocate destination image and its representation */
151    destImage = [[PRImage alloc] initWithSize:NSMakeSize(h, w)]; /* we swap h and w */
152    destImageRep = [[NSBitmapImageRep alloc]
153            initWithBitmapDataPlanes:NULL
154                          pixelsWide:h
155                          pixelsHigh:w
156                       bitsPerSample:[srcImageRep bitsPerSample]
157                     samplesPerPixel:destSamplesPerPixel
158                            hasAlpha:[srcImageRep hasAlpha]
159                            isPlanar:NO
160                      colorSpaceName:[srcImageRep colorSpaceName]
161                         bytesPerRow:0
162                        bitsPerPixel:0];
163
164    srcData = [srcImageRep bitmapData];
165    destData = [destImageRep bitmapData];
166    destBytesPerRow = [destImageRep bytesPerRow];
167    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
168
169    for (y = 0; y < h; y++)
170        for (x = 0; x < w; x++)
171        {
172            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
173            p2 = destData + destBytesPerRow * (w-x-1) + destBytesPerPixel * y;
174            for (s = 0; s < srcSamplesPerPixel; s++)
175                p2[s] = p1[s];
176        }
177
178    [destImage setBitmapRep:destImageRep];
179    [destImageRep release];
180    [destImage autorelease];
181    return destImage;
182}
183
184- (PRImage *)rotateImage180:(PRImage *)srcImage
185{
186    NSBitmapImageRep *srcImageRep;
187    PRImage *destImage;
188    NSBitmapImageRep *destImageRep;
189    NSInteger          w, h;
190    NSInteger          x, y;
191    int s; /* sample */
192    unsigned char *srcData;
193    unsigned char *destData;
194    unsigned char *p1, *p2;
195    NSInteger          srcSamplesPerPixel;
196    NSInteger          destSamplesPerPixel;
197    register NSInteger srcBytesPerPixel;
198    register NSInteger destBytesPerPixel;
199    register NSInteger srcBytesPerRow;
200    register NSInteger destBytesPerRow;
201
202
203    /* get source image representation and associated information */
204    srcImageRep = [srcImage bitmapRep];
205
206    w = [srcImageRep pixelsWide];
207    h = [srcImageRep pixelsHigh];
208    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
209    destSamplesPerPixel = srcSamplesPerPixel;
210    srcBytesPerRow = [srcImageRep bytesPerRow];
211    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
212
213    /* execute the actual rotation */
214    /* allocate destination image and its representation */
215    destImage = [[PRImage alloc] initWithSize:NSMakeSize(w, h)];
216    destImageRep = [[NSBitmapImageRep alloc]
217            initWithBitmapDataPlanes:NULL
218                          pixelsWide:w
219                          pixelsHigh:h
220                       bitsPerSample:[srcImageRep bitsPerSample]
221                     samplesPerPixel:destSamplesPerPixel
222                            hasAlpha:[srcImageRep hasAlpha]
223                            isPlanar:NO
224                      colorSpaceName:[srcImageRep colorSpaceName]
225                         bytesPerRow:0
226                        bitsPerPixel:0];
227
228    srcData = [srcImageRep bitmapData];
229    destData = [destImageRep bitmapData];
230    destBytesPerRow = [destImageRep bytesPerRow];
231    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
232
233    for (y = 0; y < h; y++)
234        for (x = 0; x < w; x++)
235        {
236            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
237            p2 = destData + destBytesPerRow * (h-y-1) + destBytesPerPixel * (w-x-1);
238            for (s = 0; s < srcSamplesPerPixel; s++)
239                p2[s] = p1[s];
240        }
241
242    [destImage setBitmapRep:destImageRep];
243    [destImageRep release];
244    [destImage autorelease];
245    return destImage;
246}
247
248
249- (PRImage *)rotateImage270:(PRImage *)srcImage
250{
251    NSBitmapImageRep *srcImageRep;
252    PRImage *destImage;
253    NSBitmapImageRep *destImageRep;
254    NSInteger          w, h;
255    NSInteger          x, y;
256    int s;
257    unsigned char *srcData;
258    unsigned char *destData;
259    unsigned char *p1, *p2;
260    NSInteger          srcSamplesPerPixel;
261    NSInteger          destSamplesPerPixel;
262    register NSInteger srcBytesPerPixel;
263    register NSInteger destBytesPerPixel;
264    register NSInteger srcBytesPerRow;
265    register NSInteger destBytesPerRow;
266
267
268    /* get source image representation and associated information */
269    srcImageRep = [srcImage bitmapRep];
270
271    w = [srcImageRep pixelsWide];
272    h = [srcImageRep pixelsHigh];
273    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
274    destSamplesPerPixel = srcSamplesPerPixel;
275    srcBytesPerRow = [srcImageRep bytesPerRow];
276    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
277
278    /* execute the actual rotation */
279    /* allocate destination image and its representation */
280    destImage = [[PRImage alloc] initWithSize:NSMakeSize(h, w)]; /* we swap h and w */
281    destImageRep = [[NSBitmapImageRep alloc]
282            initWithBitmapDataPlanes:NULL
283                          pixelsWide:h
284                          pixelsHigh:w
285                       bitsPerSample:[srcImageRep bitsPerSample]
286                     samplesPerPixel:destSamplesPerPixel
287                            hasAlpha:[srcImageRep hasAlpha]
288                            isPlanar:NO
289                      colorSpaceName:[srcImageRep colorSpaceName]
290                         bytesPerRow:0
291                        bitsPerPixel:0];
292
293    srcData = [srcImageRep bitmapData];
294    destData = [destImageRep bitmapData];
295    destBytesPerRow = [destImageRep bytesPerRow];
296    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
297
298    for (y = 0; y < h; y++)
299        for (x = 0; x < w; x++)
300        {
301            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
302            p2 = destData + destBytesPerRow * x + destBytesPerPixel * (h-y-1);
303            for (s = 0; s < srcSamplesPerPixel; s++)
304                p2[s] = p1[s];
305        }
306
307    [destImage setBitmapRep:destImageRep];
308    [destImageRep release];
309    [destImage autorelease];
310    return destImage;
311}
312
313- (PRImage *)flipImageVert:(PRImage *)srcImage
314{
315    NSBitmapImageRep *srcImageRep;
316    PRImage *destImage;
317    NSBitmapImageRep *destImageRep;
318    NSInteger          w, h;
319    NSInteger          x, y;
320    int s;
321    unsigned char *srcData;
322    unsigned char *destData;
323    unsigned char *p1, *p2;
324    NSInteger          srcSamplesPerPixel;
325    NSInteger          destSamplesPerPixel;
326    register NSInteger srcBytesPerPixel;
327    register NSInteger destBytesPerPixel;
328    register NSInteger srcBytesPerRow;
329    register NSInteger destBytesPerRow;
330
331
332    /* get source image representation and associated information */
333    srcImageRep = [srcImage bitmapRep];
334
335    w = [srcImageRep pixelsWide];
336    h = [srcImageRep pixelsHigh];
337    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
338    destSamplesPerPixel = srcSamplesPerPixel;
339    srcBytesPerRow = [srcImageRep bytesPerRow];
340    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
341
342    /* execute the actual rotation */
343    /* allocate destination image and its representation */
344    destImage = [[PRImage alloc] initWithSize:NSMakeSize(w, h)];
345    destImageRep = [[NSBitmapImageRep alloc]
346            initWithBitmapDataPlanes:NULL
347                          pixelsWide:w
348                          pixelsHigh:h
349                       bitsPerSample:[srcImageRep bitsPerSample]
350                     samplesPerPixel:destSamplesPerPixel
351                            hasAlpha:[srcImageRep hasAlpha]
352                            isPlanar:NO
353                      colorSpaceName:[srcImageRep colorSpaceName]
354                         bytesPerRow:0
355                        bitsPerPixel:0];
356
357    srcData = [srcImageRep bitmapData];
358    destData = [destImageRep bitmapData];
359    destBytesPerRow = [destImageRep bytesPerRow];
360    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
361
362    for (y = 0; y < h; y++)
363        for (x = 0; x < w; x++)
364        {
365            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
366            p2 = destData + destBytesPerRow * (h-y-1) + destBytesPerPixel * x;
367            for (s = 0; s < srcSamplesPerPixel; s++)
368                p2[s] = p1[s];
369        }
370
371    [destImage setBitmapRep:destImageRep];
372    [destImageRep release];
373    [destImage autorelease];
374    return destImage;
375}
376
377- (PRImage *)flipImageHoriz:(PRImage *)srcImage
378{
379    NSBitmapImageRep *srcImageRep;
380    PRImage *destImage;
381    NSBitmapImageRep *destImageRep;
382    NSInteger w, h;
383    NSInteger x, y;
384    int s;
385    unsigned char *srcData;
386    unsigned char *destData;
387    unsigned char *p1, *p2;
388    NSInteger          srcSamplesPerPixel;
389    NSInteger          destSamplesPerPixel;
390    register NSInteger srcBytesPerPixel;
391    register NSInteger destBytesPerPixel;
392    register NSInteger srcBytesPerRow;
393    register NSInteger destBytesPerRow;
394
395
396    /* get source image representation and associated information */
397    srcImageRep = [srcImage bitmapRep];
398
399    w = [srcImageRep pixelsWide];
400    h = [srcImageRep pixelsHigh];
401    srcSamplesPerPixel = [srcImageRep samplesPerPixel];
402    destSamplesPerPixel = srcSamplesPerPixel;
403    srcBytesPerRow = [srcImageRep bytesPerRow];
404    srcBytesPerPixel = [srcImageRep bitsPerPixel] / 8;
405
406    /* execute the actual rotation */
407    /* allocate destination image and its representation */
408    destImage = [[PRImage alloc] initWithSize:NSMakeSize(w, h)];
409    destImageRep = [[NSBitmapImageRep alloc]
410            initWithBitmapDataPlanes:NULL
411                          pixelsWide:w
412                          pixelsHigh:h
413                       bitsPerSample:[srcImageRep bitsPerSample]
414                     samplesPerPixel:destSamplesPerPixel
415                            hasAlpha:[srcImageRep hasAlpha]
416                            isPlanar:NO
417                      colorSpaceName:[srcImageRep colorSpaceName]
418                         bytesPerRow:0
419                        bitsPerPixel:0];
420
421    srcData = [srcImageRep bitmapData];
422    destData = [destImageRep bitmapData];
423    destBytesPerRow = [destImageRep bytesPerRow];
424    destBytesPerPixel = [destImageRep bitsPerPixel] / 8;
425
426    for (y = 0; y < h; y++)
427        for (x = 0; x < w; x++)
428        {
429            p1 = srcData + srcBytesPerRow * y  + srcBytesPerPixel * x;
430            p2 = destData + destBytesPerRow * y + destBytesPerPixel * (w-x-1);
431            for (s = 0; s < srcSamplesPerPixel; s++)
432                p2[s] = p1[s];
433        }
434
435    [destImage setBitmapRep:destImageRep];
436    [destImageRep release];
437    [destImage autorelease];
438    return destImage;
439}
440
441- (BOOL)displayProgress
442{
443    return NO;
444}
445
446@end
447