Subversion Repositories Scribus

Rev

Rev 5917 | Rev 5941 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
2004 fschmid 7
#include "scimage.h"
8
#include "scribus.h"
5917 jghali 9
#include "scpaths.h"
5243 cbradney 10
#include "scribuscore.h"
5937 jghali 11
#include "scimgdataloader_jpeg.h"
12
#include "scimgdataloader_pdf.h"
13
#include "scimgdataloader_ps.h"
14
#include "scimgdataloader_psd.h"
15
#include "scimgdataloader_pdf.h"
16
#include "scimgdataloader_qt.h"
17
#include "scimgdataloader_tiff.h"
2074 fschmid 18
#include <qtextstream.h>
5937 jghali 19
#include <memory>
2125 cbradney 20
#include <cassert>
2004 fschmid 21
#ifdef HAVE_CMS
22
        #include CMS_INC
23
#endif
4506 cbradney 24
#include "gsutil.h"
3685 fschmid 25
#include "exif.h"
4546 subik 26
#include "commonstrings.h"
5712 fschmid 27
#include "util.h"
2004 fschmid 28
 
5937 jghali 29
using namespace std;
30
 
2004 fschmid 31
typedef struct my_error_mgr
32
{
33
        struct jpeg_error_mgr pub;            /* "public" fields */
34
        jmp_buf setjmp_buffer;  /* for return to caller */
35
}
36
*my_error_ptr;
37
 
38
static void my_error_exit (j_common_ptr cinfo)
39
{
40
        my_error_ptr myerr = (my_error_ptr) cinfo->err;
41
        (*cinfo->err->output_message) (cinfo);
42
        longjmp (myerr->setjmp_buffer, 1);
43
}
44
 
4222 craig 45
ScImage::ScImage(const QImage & image) : QImage(image)
2004 fschmid 46
{
2012 fschmid 47
        initialize();
2004 fschmid 48
}
49
 
5593 avox 50
 
51
// ScImage will use implicit sharing:
52
ScImage::ScImage(const ScImage & image) : QImage(image.copy())
53
{
54
        initialize();
55
}
56
 
57
 
2004 fschmid 58
ScImage::ScImage() : QImage()
59
{
2012 fschmid 60
        initialize();
2004 fschmid 61
}
62
 
63
ScImage::ScImage( int width, int height ) : QImage( width, height, 32 )
64
{
2012 fschmid 65
        initialize();
66
}
67
 
5593 avox 68
const QImage& ScImage::qImage()
69
{
70
        return *this;
71
}
72
 
73
QImage ScImage::smoothScale(int h, int w, QImage::ScaleMode mode) const
74
{
75
        return QImage::smoothScale(h,w,mode);
76
}
77
 
78
 
2012 fschmid 79
void ScImage::initialize()
80
{
2004 fschmid 81
        imgInfo.xres = 72;
82
        imgInfo.yres = 72;
83
        imgInfo.colorspace = 0;
84
        imgInfo.valid = false;
85
        imgInfo.isRequest = false;
5567 mrdocs 86
        imgInfo.isEmbedded = false;
2004 fschmid 87
        imgInfo.progressive = false;
3703 fschmid 88
        imgInfo.exifDataValid = false;
2025 fschmid 89
        imgInfo.lowResType = 1;
90
        imgInfo.lowResScale = 1.0;
2004 fschmid 91
        imgInfo.PDSpathData.clear();
92
        imgInfo.RequestProps.clear();
93
        imgInfo.clipPath = "";
94
        imgInfo.usedPath = "";
95
        imgInfo.layerInfo.clear();
3703 fschmid 96
        imgInfo.exifInfo.cameraName = "";
97
        imgInfo.exifInfo.cameraVendor = "";
98
        imgInfo.exifInfo.thumbnail = QImage();
4331 fschmid 99
        imgInfo.BBoxX = 0;
100
        imgInfo.BBoxH = 0;
2004 fschmid 101
}
102
 
4050 cbradney 103
ScImage::~ScImage()
104
{
105
        curveTable.resize(0);
106
}
107
 
2886 fschmid 108
void ScImage::applyEffect(QValueList<imageEffect> effectsList, QMap<QString,ScColor> colors, bool cmyk)
2074 fschmid 109
{
110
        if (effectsList.count() != 0)
111
        {
112
                for (uint a = 0; a < effectsList.count(); ++a)
113
                {
2082 fschmid 114
                        if ((*effectsList.at(a)).effectCode == EF_INVERT)
2074 fschmid 115
                                invert(cmyk);
2082 fschmid 116
                        if ((*effectsList.at(a)).effectCode == EF_GRAYSCALE)
2074 fschmid 117
                                toGrayscale(cmyk);
2082 fschmid 118
                        if ((*effectsList.at(a)).effectCode == EF_COLORIZE)
2074 fschmid 119
                        {
120
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
4546 subik 121
                                QString col = CommonStrings::None;
2074 fschmid 122
                                int shading = 100;
123
                                QTextStream fp(&tmpstr, IO_ReadOnly);
124
                                fp >> col;
125
                                fp >> shading;
126
                                colorize(colors[col], shading, cmyk);
127
                        }
2082 fschmid 128
                        if ((*effectsList.at(a)).effectCode == EF_BRIGHTNESS)
129
                        {
130
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
131
                                int brightnessValue = 0;
132
                                QTextStream fp(&tmpstr, IO_ReadOnly);
133
                                fp >> brightnessValue;
134
                                brightness(brightnessValue, cmyk);
135
                        }
136
                        if ((*effectsList.at(a)).effectCode == EF_CONTRAST)
137
                        {
138
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
139
                                int contrastValue = 0;
140
                                QTextStream fp(&tmpstr, IO_ReadOnly);
141
                                fp >> contrastValue;
142
                                contrast(contrastValue, cmyk);
143
                        }
2092 fschmid 144
                        if ((*effectsList.at(a)).effectCode == EF_SHARPEN)
145
                        {
146
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
147
                                double radius, sigma;
148
                                QTextStream fp(&tmpstr, IO_ReadOnly);
149
                                fp >> radius;
150
                                fp >> sigma;
151
                                sharpen(radius, sigma);
152
                        }
2095 fschmid 153
                        if ((*effectsList.at(a)).effectCode == EF_BLUR)
154
                        {
155
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
156
                                double radius, sigma;
157
                                QTextStream fp(&tmpstr, IO_ReadOnly);
158
                                fp >> radius;
159
                                fp >> sigma;
160
                                blur(radius, sigma);
161
                        }
2096 fschmid 162
                        if ((*effectsList.at(a)).effectCode == EF_SOLARIZE)
163
                        {
164
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
165
                                double sigma;
166
                                QTextStream fp(&tmpstr, IO_ReadOnly);
167
                                fp >> sigma;
168
                                solarize(sigma, cmyk);
169
                        }
2074 fschmid 170
                }
171
        }
172
}
173
 
2095 fschmid 174
void ScImage::liberateMemory(void **memory)
175
{
176
        assert(memory != (void **)NULL);
177
        if(*memory == (void *)NULL)
178
                return;
179
        free(*memory);
180
        *memory=(void *) NULL;
181
}
182
 
2096 fschmid 183
void ScImage::solarize(double factor, bool cmyk)
184
{
185
        curveTable.resize(256);
186
        int fk = qRound(255 / factor);
187
        for (int i = 0; i < 256; ++i)
188
        {
189
                curveTable[i] = QMIN(255, static_cast<int>(i / fk) * fk);
190
        }
191
        applyCurve(cmyk);
192
}
193
 
2095 fschmid 194
void ScImage::blurScanLine(double *kernel, int width, unsigned int *src, unsigned int *dest, int columns)
195
{
196
        register double *p;
197
        unsigned int *q;
198
        register int x;
199
        register long i;
200
        double red, green, blue, alpha;
201
        double scale = 0.0;
202
        if(width > columns)
203
        {
204
                for(x=0; x < columns; ++x)
205
                {
206
                        scale = 0.0;
207
                        red = blue = green = alpha = 0.0;
208
                        p = kernel;
209
                        q = src;
210
                        for(i=0; i < columns; ++i)
211
                        {
212
                                if((i >= (x-width/2)) && (i <= (x+width/2)))
213
                                {
214
                                        red += (*p)*(qRed(*q)*257);
215
                                        green += (*p)*(qGreen(*q)*257);
216
                                        blue += (*p)*(qBlue(*q)*257);
217
                                        alpha += (*p)*(qAlpha(*q)*257);
218
                                }
219
                                if(((i+width/2-x) >= 0) && ((i+width/2-x) < width))
220
                                        scale+=kernel[i+width/2-x];
221
                                p++;
222
                                q++;
223
                        }
224
                        scale = 1.0/scale;
225
                        red = scale*(red+0.5);
226
                        green = scale*(green+0.5);
227
                        blue = scale*(blue+0.5);
228
                        alpha = scale*(alpha+0.5);
229
                        red = red < 0 ? 0 : red > 65535 ? 65535 : red;
230
                        green = green < 0 ? 0 : green > 65535 ? 65535 : green;
231
                        blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue;
232
                        alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha;
233
                        dest[x] = qRgba((unsigned char)(red/257UL),
234
                                        (unsigned char)(green/257UL),
235
                                        (unsigned char)(blue/257UL),
236
                                        (unsigned char)(alpha/257UL));
237
                }
238
                return;
239
        }
240
 
241
        for(x=0; x < width/2; ++x)
242
        {
243
                scale = 0.0;
244
                red = blue = green = alpha = 0.0;
245
                p = kernel+width/2-x;
246
                q = src;
247
                for(i=width/2-x; i < width; ++i)
248
                {
249
                        red += (*p)*(qRed(*q)*257);
250
                        green += (*p)*(qGreen(*q)*257);
251
                        blue += (*p)*(qBlue(*q)*257);
252
                        alpha += (*p)*(qAlpha(*q)*257);
253
                        scale += (*p);
254
                        p++;
255
                        q++;
256
                }
257
                scale=1.0/scale;
258
                red = scale*(red+0.5);
259
                green = scale*(green+0.5);
260
                blue = scale*(blue+0.5);
261
                alpha = scale*(alpha+0.5);
262
                red = red < 0 ? 0 : red > 65535 ? 65535 : red;
263
                green = green < 0 ? 0 : green > 65535 ? 65535 : green;
264
                blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue;
265
                alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha;
266
                dest[x] = qRgba((unsigned char)(red/257UL),
267
                                (unsigned char)(green/257UL),
268
                                (unsigned char)(blue/257UL),
269
                                (unsigned char)(alpha/257UL));
270
        }
271
        for(; x < columns-width/2; ++x)
272
        {
273
                red = blue = green = alpha = 0.0;
274
                p = kernel;
275
                q = src+(x-width/2);
276
                for (i=0; i < (long) width; ++i)
277
                {
278
                        red += (*p)*(qRed(*q)*257);
279
                        green += (*p)*(qGreen(*q)*257);
280
                        blue += (*p)*(qBlue(*q)*257);
281
                        alpha += (*p)*(qAlpha(*q)*257);
282
                        p++;
283
                        q++;
284
                }
285
                red = scale*(red+0.5);
286
                green = scale*(green+0.5);
287
                blue = scale*(blue+0.5);
288
                alpha = scale*(alpha+0.5);
289
                red = red < 0 ? 0 : red > 65535 ? 65535 : red;
290
                green = green < 0 ? 0 : green > 65535 ? 65535 : green;
291
                blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue;
292
                alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha;
293
                dest[x] = qRgba((unsigned char)(red/257UL),
294
                                (unsigned char)(green/257UL),
295
                                (unsigned char)(blue/257UL),
296
                                (unsigned char)(alpha/257UL));
297
        }
298
        for(; x < columns; ++x)
299
        {
300
                red = blue = green = alpha = 0.0;
301
                scale=0;
302
                p = kernel;
303
                q = src+(x-width/2);
304
                for(i=0; i < columns-x+width/2; ++i)
305
                {
306
                        red += (*p)*(qRed(*q)*257);
307
                        green += (*p)*(qGreen(*q)*257);
308
                        blue += (*p)*(qBlue(*q)*257);
309
                        alpha += (*p)*(qAlpha(*q)*257);
310
                        scale += (*p);
311
                        p++;
312
                        q++;
313
                }
314
                scale=1.0/scale;
315
                red = scale*(red+0.5);
316
                green = scale*(green+0.5);
317
                blue = scale*(blue+0.5);
318
                alpha = scale*(alpha+0.5);
319
                red = red < 0 ? 0 : red > 65535 ? 65535 : red;
320
                green = green < 0 ? 0 : green > 65535 ? 65535 : green;
321
                blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue;
322
                alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha;
323
                dest[x] = qRgba((unsigned char)(red/257UL),
324
                                (unsigned char)(green/257UL),
325
                                (unsigned char)(blue/257UL),
326
                                (unsigned char)(alpha/257UL));
327
        }
328
}
329
 
330
int ScImage::getBlurKernel(int width, double sigma, double **kernel)
331
{
332
        double alpha, normalize;
333
        register long i;
334
        int bias;
335
        assert(sigma != 0.0);
336
        if(width == 0)
337
                width = 3;
338
        *kernel=(double *)malloc(width*sizeof(double));
339
        if(*kernel == (double *)NULL)
340
                return(0);
341
        memset(*kernel, 0, width*sizeof(double));
342
        bias = 3*width/2;
343
        for(i=(-bias); i <= bias; i++)
344
        {
345
                alpha=exp(-((double) i*i)/(2.0*3*3*sigma*sigma));
346
                (*kernel)[(i+bias)/3]+=alpha/(2.50662827463100024161235523934010416269302368164062*sigma);
347
        }
348
        normalize=0;
349
        for(i=0; i < width; i++)
350
                normalize+=(*kernel)[i];
351
        for(i=0; i < width; i++)
352
                (*kernel)[i]/=normalize;
353
        return(width);
354
}
355
 
356
void ScImage::blur(double radius, double sigma)
357
{
358
        double *kernel;
359
        QImage dest;
360
        int widthk;
361
        int x, y;
362
        unsigned int *scanline, *temp;
363
        unsigned int *p, *q;
364
        if(sigma == 0.0)
365
                return;
366
        kernel=(double *) NULL;
367
        if(radius > 0)
368
                widthk=getBlurKernel((int) (2*ceil(radius)+1),sigma,&kernel);
369
        else
370
        {
371
                double *last_kernel;
372
                last_kernel=(double *) NULL;
373
                widthk=getBlurKernel(3,sigma,&kernel);
374
                while ((long) (255*kernel[0]) > 0)
375
                {
376
                        if(last_kernel != (double *)NULL)
377
                        {
378
                                liberateMemory((void **) &last_kernel);
379
                        }
380
                        last_kernel=kernel;
381
                        kernel = (double *)NULL;
382
                        widthk = getBlurKernel(widthk+2, sigma, &kernel);
383
                }
384
                if(last_kernel != (double *) NULL)
385
                {
386
                        liberateMemory((void **) &kernel);
387
                        widthk-=2;
388
                        kernel = last_kernel;
389
                }
390
        }
391
        if(widthk < 3)
392
        {
393
                liberateMemory((void **) &kernel);
394
                return;
395
        }
396
        dest.create(width(), height(), 32);
397
        scanline = (unsigned int *)malloc(sizeof(unsigned int)*height());
398
        temp = (unsigned int *)malloc(sizeof(unsigned int)*height());
399
        for(y=0; y < height(); ++y)
400
        {
401
                p = (unsigned int *)scanLine(y);
402
                q = (unsigned int *)dest.scanLine(y);
403
                blurScanLine(kernel, widthk, p, q, width());
404
        }
5937 jghali 405
        unsigned int **srcTable = (unsigned int **) jumpTable();
406
        unsigned int **destTable = (unsigned int **) dest.jumpTable();
2095 fschmid 407
        for(x=0; x < width(); ++x)
408
        {
409
                for(y=0; y < height(); ++y)
410
                {
411
                        scanline[y] = srcTable[y][x];
412
                }
413
                blurScanLine(kernel, widthk, scanline, temp, height());
414
                for(y=0; y < height(); ++y)
415
                {
416
                        destTable[y][x] = temp[y];
417
                }
418
        }
419
        liberateMemory((void **) &scanline);
420
        liberateMemory((void **) &temp);
421
        liberateMemory((void **) &kernel);
422
        for( int yi=0; yi < dest.height(); ++yi )
423
        {
424
                QRgb *s = (QRgb*)(dest.scanLine( yi ));
425
                QRgb *d = (QRgb*)(scanLine( yi ));
426
                for(int xi=0; xi < dest.width(); ++xi )
427
                {
428
                        (*d) = (*s);
429
                        s++;
430
                        d++;
431
                }
432
        }
433
        return;
434
}
435
 
2092 fschmid 436
bool ScImage::convolveImage(QImage *dest, const unsigned int order, const double *kernel)
437
{
438
        long widthk;
439
        double red, green, blue, alpha;
440
        double normalize, *normal_kernel;
441
        register const double *k;
442
        register unsigned int *q;
443
        int x, y, mx, my, sx, sy;
444
        long i;
445
        int mcx, mcy;
446
        widthk = order;
447
        if((widthk % 2) == 0)
448
                return(false);
449
        normal_kernel = (double *)malloc(widthk*widthk*sizeof(double));
450
        if(!normal_kernel)
451
                return(false);
452
        dest->reset();
453
        dest->create(width(), height(), 32);
454
        normalize=0.0;
455
        for(i=0; i < (widthk*widthk); i++)
456
                normalize += kernel[i];
457
        if(fabs(normalize) <= 1.0e-12)
458
                normalize=1.0;
459
        normalize=1.0/normalize;
460
        for(i=0; i < (widthk*widthk); i++)
461
                normal_kernel[i] = normalize*kernel[i];
462
        unsigned int **jumpTablek = (unsigned int **)jumpTable();
463
        for(y=0; y < dest->height(); ++y)
464
        {
465
                sy = y-(widthk/2);
466
                q = (unsigned int *)dest->scanLine(y);
467
                for(x=0; x < dest->width(); ++x)
468
                {
469
                        k = normal_kernel;
470
                        red = green = blue = alpha = 0;
471
                        sy = y-(widthk/2);
472
                        for(mcy=0; mcy < widthk; ++mcy, ++sy)
473
                        {
474
                                my = sy < 0 ? 0 : sy > height()-1 ? height()-1 : sy;
475
                                sx = x+(-widthk/2);
476
                                for(mcx=0; mcx < widthk; ++mcx, ++sx)
477
                                {
478
                                        mx = sx < 0 ? 0 : sx > width()-1 ? width()-1 : sx;
479
                                        red += (*k)*(qRed(jumpTablek[my][mx])*257);
480
                                        green += (*k)*(qGreen(jumpTablek[my][mx])*257);
481
                                        blue += (*k)*(qBlue(jumpTablek[my][mx])*257);
482
                                        alpha += (*k)*(qAlpha(jumpTablek[my][mx])*257);
483
                                        ++k;
484
                                }
485
                        }
486
                        red = red < 0 ? 0 : red > 65535 ? 65535 : red+0.5;
487
                        green = green < 0 ? 0 : green > 65535 ? 65535 : green+0.5;
488
                        blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue+0.5;
489
                        alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha+0.5;
490
                        *q++ = qRgba((unsigned char)(red/257UL),
2095 fschmid 491
                                     (unsigned char)(green/257UL),
492
                                     (unsigned char)(blue/257UL),
493
                                     (unsigned char)(alpha/257UL));
2092 fschmid 494
                }
495
        }
2095 fschmid 496
        free(normal_kernel);
2092 fschmid 497
        return(true);
498
}
499
 
500
int ScImage::getOptimalKernelWidth(double radius, double sigma)
501
{
502
        double normalize, value;
503
        long width;
504
        register long u;
505
        assert(sigma != 0.0);
506
        if(radius > 0.0)
507
                return((int)(2.0*ceil(radius)+1.0));
508
        for(width=5; ;)
509
        {
510
                normalize=0.0;
511
                for(u=(-width/2); u <= (width/2); u++)
512
                        normalize+=exp(-((double) u*u)/(2.0*sigma*sigma))/(2.50662827463100024161235523934010416269302368164062*sigma);
513
                u=width/2;
514
                value=exp(-((double) u*u)/(2.0*sigma*sigma))/(2.50662827463100024161235523934010416269302368164062*sigma)/normalize;
515
                if((long)(65535*value) <= 0)
516
                        break;
517
                width+=2;
518
        }
519
        return((int)width-2);
520
}
521
 
522
void ScImage::sharpen(double radius, double sigma)
523
{
524
        double alpha, normalize, *kernel;
525
        int widthk;
526
        register long i, u, v;
527
        QImage dest;
528
        if(sigma == 0.0)
529
                return;
530
        widthk = getOptimalKernelWidth(radius, sigma);
531
        if(width() < widthk)
532
                return;
533
        kernel = (double *)malloc(widthk*widthk*sizeof(double));
534
        if(!kernel)
535
                return;
536
        i = 0;
537
        normalize=0.0;
538
        for (v=(-widthk/2); v <= (widthk/2); v++)
539
        {
540
                for (u=(-widthk/2); u <= (widthk/2); u++)
541
                {
542
                        alpha=exp(-((double) u*u+v*v)/(2.0*sigma*sigma));
543
                        kernel[i]=alpha/(2.0*3.14159265358979323846264338327950288419716939937510*sigma*sigma);
544
                        normalize+=kernel[i];
545
                        i++;
546
                }
547
        }
548
        kernel[i/2]=(-2.0)*normalize;
549
        convolveImage(&dest, widthk, kernel);
2095 fschmid 550
        liberateMemory((void **) &kernel);
2092 fschmid 551
        for( int yi=0; yi < dest.height(); ++yi )
552
        {
553
                QRgb *s = (QRgb*)(dest.scanLine( yi ));
554
                QRgb *d = (QRgb*)(scanLine( yi ));
555
                for(int xi=0; xi < dest.width(); ++xi )
556
                {
557
                        (*d) = (*s);
558
                        s++;
559
                        d++;
560
                }
561
        }
562
        return;
563
}
564
 
2082 fschmid 565
void ScImage::contrast(int contrastValue, bool cmyk)
566
{
567
        curveTable.resize(256);
568
        QPoint p1(0,0 - contrastValue);
569
        QPoint p2(256, 256 + contrastValue);
570
        double mc = (p1.y() - p2.y()) / (double)(p1.x() - p2.x());
571
        for (int i = 0; i < 256; ++i)
572
        {
573
                curveTable[i] = QMIN(255, QMAX(0, int(i * mc) + p1.y()));
574
        }
575
        applyCurve(cmyk);
576
}
577
 
578
void ScImage::brightness(int brightnessValue, bool cmyk)
579
{
580
        curveTable.resize(256);
581
        QPoint p1(0,0 + brightnessValue);
582
        QPoint p2(256, 256 + brightnessValue);
583
        double mc = (p1.y() - p2.y()) / (double)(p1.x() - p2.x());
584
        for (int i = 0; i < 256; ++i)
585
        {
586
                curveTable[i] = QMIN(255, QMAX(0, int(i * mc) + p1.y()));
587
        }
588
        applyCurve(cmyk);
589
}
590
 
591
void ScImage::applyCurve(bool cmyk)
592
{
593
        int h = height();
594
        int w = width();
595
        for( int yi=0; yi < h; ++yi )
596
        {
597
                QRgb * s = (QRgb*)(scanLine( yi ));
598
                for( int xi=0; xi < w; ++xi )
599
                {
600
                        QRgb r=*s;
601
                        int c, m, y, k;
602
                        if (cmyk)
603
                        {
2766 cbradney 604
                                unsigned char *p = (unsigned char *) s;
605
                                unsigned char rc = 255 - QMIN(255, p[0] + p[3]);
606
                                unsigned char gc = 255 - QMIN(255, p[1] + p[3]);
607
                                unsigned char bc = 255 - QMIN(255, p[2] + p[3]);
4419 cbradney 608
                                c = 255 - curveTable[(int)rc];
609
                                m = 255 - curveTable[(int)gc];
610
                                y = 255 - curveTable[(int)bc];
2082 fschmid 611
                                k = QMIN(QMIN(c, m), y);
612
                                *s = qRgba(y - k, m - k, c - k, k );
613
                        }
614
                        else
615
                        {
616
                                c = curveTable[qRed(r)];
617
                                m = curveTable[qGreen(r)];
618
                                y = curveTable[qBlue(r)];
619
                                k = qAlpha(r);
620
                                *s = qRgba(c, m, y, k);
621
                        }
622
                        s++;
623
                }
624
        }
625
}
626
 
2886 fschmid 627
void ScImage::colorize(ScColor color, int shade, bool cmyk)
2053 fschmid 628
{
629
        int h = height();
630
        int w = width();
631
        int cc, cm, cy, ck;
2057 fschmid 632
        int hu, sa, v;
2886 fschmid 633
        ScColor tmp2;
2057 fschmid 634
        QColor tmpR;
2053 fschmid 635
        if (cmyk)
2057 fschmid 636
                color.getShadeColorCMYK(&cc, &cm, &cy, &ck, shade);
2053 fschmid 637
        else
638
        {
639
                ck = 0;
2057 fschmid 640
                color.getShadeColorRGB(&cc, &cm, &cy, shade);
2053 fschmid 641
        }
642
        for( int yi=0; yi < h; ++yi )
643
        {
644
                QRgb * s = (QRgb*)(scanLine( yi ));
645
                for( int xi=0; xi < w; ++xi )
646
                {
647
                        QRgb r=*s;
648
                        if (cmyk)
649
                        {
2057 fschmid 650
                                double k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255) / 255.0;
2053 fschmid 651
                                *s = qRgba(QMIN(qRound(cc*k), 255), QMIN(qRound(cm*k), 255), QMIN(qRound(cy*k), 255), QMIN(qRound(ck*k), 255));
652
                        }
653
                        else
654
                        {
2057 fschmid 655
                                int k = 255 - QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
656
                                int cc2, cm2, cy2;
657
                                tmpR.setRgb(cc, cm, cy);
658
                                tmpR.hsv(&hu, &sa, &v);
659
                                if (cc == cm && cm == cy)
660
                                        tmpR.setHsv(hu, sa, 255 - ((255 - v) * k / 255));
661
                                else
662
                                        tmpR.setHsv(hu, sa * k / 255, v);
663
                                tmpR.getRgb(&cc2, &cm2, &cy2);
2053 fschmid 664
                                int a = qAlpha(r);
2057 fschmid 665
                                *s = qRgba(cc2, cm2, cy2, a);
2053 fschmid 666
                        }
667
                        s++;
668
                }
669
        }
670
}
671
 
2057 fschmid 672
void ScImage::invert(bool cmyk)
673
{
674
        int h = height();
675
        int w = width();
676
        for( int yi=0; yi < h; ++yi )
677
        {
678
                QRgb * s = (QRgb*)(scanLine( yi ));
679
                for( int xi=0; xi < w; ++xi )
680
                {
681
                        if (cmyk)
682
                        {
2766 cbradney 683
                                unsigned char *p = (unsigned char *) s;
2057 fschmid 684
                                unsigned char c, m, y, k;
2766 cbradney 685
                                c = 255 - QMIN(255, p[0] + p[3]);
686
                                m = 255 - QMIN(255, p[1] + p[3]);
687
                                y = 255 - QMIN(255, p[2] + p[3]);
2061 fschmid 688
                                k = QMIN(QMIN(c, m), y);
2766 cbradney 689
                                p[0] = c - k;
690
                                p[1] = m - k;
691
                                p[2] = y - k;
692
                                p[3] = k;
2057 fschmid 693
                        }
694
                        else
2766 cbradney 695
                                *s ^= 0x00ffffff;
2057 fschmid 696
                        s++;
697
                }
698
        }
699
}
700
 
2053 fschmid 701
void ScImage::toGrayscale(bool cmyk)
702
{
703
        int h = height();
704
        int w = width();
705
        for( int yi=0; yi < h; ++yi )
706
        {
707
                QRgb * s = (QRgb*)(scanLine( yi ));
708
                for( int xi=0; xi < w; ++xi )
709
                {
710
                        QRgb r=*s;
711
                        int k;
712
                        if (cmyk)
713
                        {
2056 fschmid 714
                                k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255);
2053 fschmid 715
                                *s = qRgba(0, 0, 0, k);
716
                        }
717
                        else
718
                        {
719
                                k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
720
                                int a = qAlpha(r);
721
                                *s = qRgba(k, k, k, a);
722
                        }
723
                        s++;
724
                }
725
        }
726
}
727
 
2012 fschmid 728
void ScImage::swapRGBA()
729
{
730
        for (int i = 0; i < height(); ++i)
731
        {
2766 cbradney 732
                unsigned int *ptr = (unsigned int *) scanLine(i);
733
                unsigned char r, b;
2012 fschmid 734
                for (int j = 0; j < width(); ++j)
735
                {
736
                        unsigned char *p = (unsigned char *) ptr;
2766 cbradney 737
                        r = p[0];
738
                        b = p[2];
739
                        p[2] = r;
740
                        p[0] = b;
741
                        ptr++;
2012 fschmid 742
                }
743
        }
744
}
745
 
2025 fschmid 746
void ScImage::createLowRes(double scale)
2012 fschmid 747
{
2025 fschmid 748
        int w = qRound(width() / scale);
749
        int h = qRound(height() / scale);
2012 fschmid 750
        QImage tmp = smoothScale(w, h);
751
        create(w, h, 32);
752
        for( int yi=0; yi < tmp.height(); ++yi )
753
        {
754
                QRgb *s = (QRgb*)(tmp.scanLine( yi ));
755
                QRgb *d = (QRgb*)(scanLine( yi ));
756
                for(int xi=0; xi < tmp.width(); ++xi )
757
                {
758
                        (*d) = (*s);
759
                        s++;
760
                        d++;
761
                }
762
        }
763
}
764
 
2004 fschmid 765
void ScImage::Convert2JPG(QString fn, int Quality, bool isCMYK, bool isGray)
766
{
767
        struct jpeg_compress_struct cinfo;
768
        struct my_error_mgr         jerr;
769
        FILE     *outfile;
770
        JSAMPROW row_pointer[1];
771
        row_pointer[0] = 0;
772
        cinfo.err = jpeg_std_error (&jerr.pub);
773
        jerr.pub.error_exit = my_error_exit;
774
        outfile = NULL;
775
        if (setjmp (jerr.setjmp_buffer))
776
        {
777
                jpeg_destroy_compress (&cinfo);
778
                if (outfile)
779
                        fclose (outfile);
780
                return;
781
        }
782
        jpeg_create_compress (&cinfo);
2643 craig 783
        if ((outfile = fopen (fn.local8Bit(), "wb")) == NULL)
2004 fschmid 784
                return;
785
        jpeg_stdio_dest (&cinfo, outfile);
786
        cinfo.image_width  = width();
787
        cinfo.image_height = height();
788
        if (isCMYK)
789
        {
790
                cinfo.in_color_space = JCS_CMYK;
791
                cinfo.input_components = 4;
792
        }
793
        else
794
        {
795
                if (isGray)
796
                {
797
                        cinfo.in_color_space = JCS_GRAYSCALE;
798
                        cinfo.input_components = 1;
799
                }
800
                else
801
                {
802
                        cinfo.in_color_space = JCS_RGB;
803
                        cinfo.input_components = 3;
804
                }
805
        }
806
        jpeg_set_defaults (&cinfo);
807
        int qual[] = { 95, 85, 75, 50, 25 };  // These are the JPEG Quality settings 100 means best, 0 .. don't discuss
808
        jpeg_set_quality (&cinfo, qual[Quality], true);
2680 cbradney 809
        jpeg_start_compress (&cinfo, true);
2004 fschmid 810
        row_pointer[0] = new uchar[cinfo.image_width*cinfo.input_components];
811
        int w = cinfo.image_width;
812
        while (cinfo.next_scanline < cinfo.image_height)
813
        {
814
                uchar *row = row_pointer[0];
815
                if (isCMYK)
816
                {
817
                        QRgb* rgba = (QRgb*)scanLine(cinfo.next_scanline);
818
                        for (int i=0; i<w; ++i)
819
                        {
3963 fschmid 820
                                *row++ = 255-qRed(*rgba);
821
                                *row++ = 255-qGreen(*rgba);
822
                                *row++ = 255-qBlue(*rgba);
823
                                *row++ = 255-qAlpha(*rgba);
2004 fschmid 824
                                ++rgba;
825
                        }
826
                }
827
                else
828
                {
829
                        if (isGray)
830
                        {
831
                                QRgb* rgba = (QRgb*)scanLine(cinfo.next_scanline);
832
                                for (int i=0; i<w; ++i)
833
                                {
834
                                        *row++ = qRed(*rgba);
835
                                        ++rgba;
836
                                }
837
                        }
838
                        else
839
                        {
840
                                QRgb* rgb = (QRgb*)scanLine(cinfo.next_scanline);
841
                                for (int i=0; i<w; i++)
842
                                {
843
                                        *row++ = qRed(*rgb);
844
                                        *row++ = qGreen(*rgb);
845
                                        *row++ = qBlue(*rgb);
846
                                        ++rgb;
847
                                }
848
                        }
849
                }
850
                jpeg_write_scanlines (&cinfo, row_pointer, 1);
851
        }
852
        jpeg_finish_compress (&cinfo);
853
        fclose (outfile);
854
        jpeg_destroy_compress (&cinfo);
855
        delete [] row_pointer[0];
856
}
857
 
5234 fschmid 858
QByteArray ScImage::ImageToArray()
2004 fschmid 859
{
2884 fschmid 860
        int i = 0;
2004 fschmid 861
        int h = height();
862
        int w = width();
2884 fschmid 863
        unsigned char u;
5234 fschmid 864
        QByteArray imgArray(3 * h * w);
2004 fschmid 865
        for( int yi=0; yi < h; ++yi )
866
        {
867
                QRgb * s = (QRgb*)(scanLine( yi ));
868
                for( int xi=0; xi < w; ++xi )
869
                {
870
                        QRgb r=*s++;
2884 fschmid 871
                        u=qRed(r);
5234 fschmid 872
                        imgArray[i++] = u;
2004 fschmid 873
                        u=qGreen(r);
5234 fschmid 874
                        imgArray[i++] = u;
2004 fschmid 875
                        u=qBlue(r);
5234 fschmid 876
                        imgArray[i++] = u;
2004 fschmid 877
                }
878
        }
5234 fschmid 879
        return imgArray;
2004 fschmid 880
}
881
 
5234 fschmid 882
QByteArray ScImage::ImageToGray()
2004 fschmid 883
{
2884 fschmid 884
        int i = 0;
2004 fschmid 885
        int h = height();
886
        int w = width();
5234 fschmid 887
        QByteArray imgArray(h * w);
2004 fschmid 888
        for( int yi=0; yi < h; ++yi )
889
        {
890
                QRgb * s = (QRgb*)(scanLine( yi ));
891
                for( int xi=0; xi < w; ++xi )
892
                {
893
                        QRgb r=*s;
894
                        int k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
895
                        *s = qRgba(k, 0, 0, 0);
5234 fschmid 896
                        imgArray[i++] = k;
2004 fschmid 897
                        s++;
898
                }
899
        }
5234 fschmid 900
        return imgArray;
2004 fschmid 901
}
902
 
5234 fschmid 903
QByteArray ScImage::ImageToCMYK_PDF(bool pre)
2004 fschmid 904
{
2884 fschmid 905
        int i = 0;
2004 fschmid 906
        int h = height();
907
        int w = width();
5234 fschmid 908
        QByteArray imgArray( 4 * h * w );
2004 fschmid 909
        if (pre)
910
        {
911
                for( int yi=0; yi < h; ++yi )
912
                {
913
                        QRgb * s = (QRgb*)(scanLine( yi ));
914
                        for( int xi=0; xi < w; ++xi )
915
                        {
916
                                QRgb r=*s;
917
                                int c = qRed(r);
918
                                int m = qGreen(r);
919
                                int y = qBlue(r);
920
                                int k = qAlpha(r);
5234 fschmid 921
                                imgArray[i++] = static_cast<unsigned char> (c);
922
                                imgArray[i++] = static_cast<unsigned char> (m);
923
                                imgArray[i++] = static_cast<unsigned char> (y);
924
                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 925
                                s++;
926
                        }
927
                }
928
        }
929
        else
930
        {
931
                for( int yi=0; yi < h; ++yi )
932
                {
933
                        QRgb * s = (QRgb*)(scanLine( yi ));
934
                        for( int xi=0; xi < w; ++xi )
935
                        {
936
                                QRgb r=*s;
937
                                int c = 255 - qRed(r);
938
                                int m = 255 - qGreen(r);
939
                                int y = 255 - qBlue(r);
940
                                int k = QMIN(QMIN(c, m), y);
5234 fschmid 941
                                imgArray[i++] = static_cast<unsigned char> (c - k);
942
                                imgArray[i++] = static_cast<unsigned char> (m - k);
943
                                imgArray[i++] = static_cast<unsigned char> (y - k);
944
                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 945
                                s++;
946
                        }
947
                }
948
        }
5234 fschmid 949
        return imgArray;
2004 fschmid 950
}
951
 
5234 fschmid 952
QByteArray ScImage::ImageToCMYK_PS(int pl, bool pre)
2004 fschmid 953
{
2884 fschmid 954
        int i = 0;
2004 fschmid 955
        int h = height();
956
        int w = width();
5234 fschmid 957
        QByteArray imgArray;
2884 fschmid 958
        if(pl == -1)
5234 fschmid 959
                imgArray.resize(4 * h * w);
2884 fschmid 960
        else
5234 fschmid 961
                imgArray.resize(h * w);
2004 fschmid 962
        if (pre)
963
        {
964
                for( int yi=0; yi < h; ++yi )
965
                {
966
                        QRgb * s = (QRgb*)(scanLine( yi ));
967
                        for( int xi=0; xi < w; ++xi )
968
                        {
969
                                QRgb r=*s++;
970
                                int c = qRed(r);
971
                                int m = qGreen(r);
972
                                int y = qBlue(r);
973
                                int k = qAlpha(r);
974
                                if (pl == -1)
975
                                {
5234 fschmid 976
                                        imgArray[i++] = static_cast<unsigned char> (c);
977
                                        imgArray[i++] = static_cast<unsigned char> (m);
978
                                        imgArray[i++] = static_cast<unsigned char> (y);
979
                                        imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 980
                                }
981
                                else
982
                                {
983
                                        if (pl == -2)
5234 fschmid 984
                                                imgArray[i++] = static_cast<unsigned char> (QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k)));
2004 fschmid 985
                                        if (pl == 1)
5234 fschmid 986
                                                imgArray[i++] = static_cast<unsigned char> (c);
2004 fschmid 987
                                        if (pl == 2)
5234 fschmid 988
                                                imgArray[i++] = static_cast<unsigned char> (m);
2004 fschmid 989
                                        if (pl == 3)
5234 fschmid 990
                                                imgArray[i++] = static_cast<unsigned char> (y);
2004 fschmid 991
                                        if (pl == 0)
5234 fschmid 992
                                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 993
                                }
994
                        }
995
                }
996
        }
997
        else
998
        {
999
                for( int yi=0; yi < h; ++yi )
1000
                {
1001
                        QRgb * s = (QRgb*)(scanLine( yi ));
1002
                        for( int xi=0; xi < w; ++xi )
1003
                        {
1004
                                QRgb r=*s++;
1005
                                int c = 255 - qRed(r);
1006
                                int m = 255 - qGreen(r);
1007
                                int y = 255 - qBlue(r);
1008
                                int k = QMIN(QMIN(c, m), y);
1009
                                if (pl == -1)
1010
                                {
5234 fschmid 1011
                                        imgArray[i++] = static_cast<unsigned char> (c - k);
1012
                                        imgArray[i++] = static_cast<unsigned char> (m - k);
1013
                                        imgArray[i++] = static_cast<unsigned char> (y - k);
1014
                                        imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1015
                                }
1016
                                else
1017
                                {
1018
                                        if (pl == -2)
5234 fschmid 1019
                                                imgArray[i++] = static_cast<unsigned char> (QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k)));
2004 fschmid 1020
                                        if (pl == 1)
5234 fschmid 1021
                                                imgArray[i++] = static_cast<unsigned char> (c - k);
2004 fschmid 1022
                                        if (pl == 2)
5234 fschmid 1023
                                                imgArray[i++] = static_cast<unsigned char> (m - k);
2004 fschmid 1024
                                        if (pl == 3)
5234 fschmid 1025
                                                imgArray[i++] = static_cast<unsigned char> (y - k);
2004 fschmid 1026
                                        if (pl == 0)
5234 fschmid 1027
                                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1028
                                }
1029
                        }
1030
                }
1031
        }
5234 fschmid 1032
        return imgArray;
2004 fschmid 1033
}
1034
 
1035
void ScImage::scaleImage(int nwidth, int nheight)
1036
{
1037
        QImage dst;
1038
        dst.create(nwidth, nheight,32);
1039
        QRgb* xelrow = 0;
1040
        QRgb* tempxelrow = 0;
1041
        register QRgb* xP;
1042
        register QRgb* nxP;
1043
        int rows, cols, rowsread, newrows, newcols;
1044
        register int row, col, needtoreadrow;
1045
        const uchar maxval = 255;
1046
        double xscale, yscale;
1047
        long sxscale, syscale;
1048
        register long fracrowtofill, fracrowleft;
1049
        long* as;
1050
        long* rs;
1051
        long* gs;
1052
        long* bs;
1053
        int rowswritten = 0;
1054
        cols = width();
1055
        rows = height();
1056
        newcols = dst.width();
1057
        newrows = dst.height();
1058
        long SCALE;
1059
        long HALFSCALE;
1060
        if (cols > 4096)
1061
        {
1062
                SCALE = 4096;
1063
                HALFSCALE = 2048;
1064
        }
1065
        else
1066
        {
1067
                int fac = 4096;
1068
                while (cols * fac > 4096)
1069
                {
1070
                        fac /= 2;
1071
                }
1072
                SCALE = fac * cols;
1073
                HALFSCALE = fac * cols / 2;
1074
        }
1075
        xscale = (double) newcols / (double) cols;
1076
        yscale = (double) newrows / (double) rows;
1077
        sxscale = (long)(xscale * SCALE);
1078
        syscale = (long)(yscale * SCALE);
1079
        if ( newrows != rows )  /* shortcut Y scaling if possible */
1080
                tempxelrow = new QRgb[cols];
1081
        as = new long[cols];
1082
        rs = new long[cols];
1083
        gs = new long[cols];
1084
        bs = new long[cols];
1085
        rowsread = 0;
1086
        fracrowleft = syscale;
1087
        needtoreadrow = 1;
1088
        for ( col = 0; col < cols; ++col )
1089
                rs[col] = gs[col] =  as[col] = bs[col] = HALFSCALE;
1090
        fracrowtofill = SCALE;
1091
        for ( row = 0; row < newrows; ++row )
1092
        {
1093
                if ( newrows == rows )
1094
                        tempxelrow = xelrow = (QRgb*)scanLine(rowsread++);
1095
                else
1096
                {
1097
                        while ( fracrowleft < fracrowtofill )
1098
                        {
1099
                                if ( needtoreadrow && rowsread < rows )
1100
                                        xelrow = (QRgb*)scanLine(rowsread++);
1101
                                for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
1102
                                {
1103
                                        as[col] += fracrowleft * qAlpha( *xP );
1104
                                        rs[col] += fracrowleft * qRed( *xP );
1105
                                        gs[col] += fracrowleft * qGreen( *xP );
1106
                                        bs[col] += fracrowleft * qBlue( *xP );
1107
                                }
1108
                                fracrowtofill -= fracrowleft;
1109
                                fracrowleft = syscale;
1110
                                needtoreadrow = 1;
1111
                        }
1112
                        if ( needtoreadrow && rowsread < rows )
1113
                        {
1114
                                xelrow = (QRgb*)scanLine(rowsread++);
1115
                                needtoreadrow = 0;
1116
                        }
1117
                        register long a=0;
1118
                        for ( col = 0, xP = xelrow, nxP = tempxelrow; col < cols; ++col, ++xP, ++nxP )
1119
                        {
1120
                                register long r, g, b;
1121
                                a = as[col] + fracrowtofill * qAlpha( *xP );
1122
                                r = rs[col] + fracrowtofill * qRed( *xP );
1123
                                g = gs[col] + fracrowtofill * qGreen( *xP );
1124
                                b = bs[col] + fracrowtofill * qBlue( *xP );
1125
                                r /= SCALE;
1126
                                if ( r > maxval ) r = maxval;
1127
                                g /= SCALE;
1128
                                if ( g > maxval ) g = maxval;
1129
                                b /= SCALE;
1130
                                if ( b > maxval ) b = maxval;
1131
                                a /= SCALE;
1132
                                if ( a > maxval ) a = maxval;
1133
                                *nxP = qRgba( (int)r, (int)g, (int)b , (int)a);
1134
                                rs[col] = as[col] = gs[col] = bs[col] = HALFSCALE;
1135
                        }
1136
                        fracrowleft -= fracrowtofill;
1137
                        if ( fracrowleft == 0 )
1138
                        {
1139
                                fracrowleft = syscale;
1140
                                needtoreadrow = 1;
1141
                        }
1142
                        fracrowtofill = SCALE;
1143
                }
1144
                if ( newcols == cols )
1145
                        memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
1146
                else
1147
                {
1148
                        register long a, r, g, b;
1149
                        register long fraccoltofill, fraccolleft = 0;
1150
                        register int needcol;
1151
                        nxP = (QRgb*)dst.scanLine(rowswritten++);
1152
                        fraccoltofill = SCALE;
1153
                        a = r = g = b = HALFSCALE;
1154
                        needcol = 0;
1155
                        for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP )
1156
                        {
1157
                                fraccolleft = sxscale;
1158
                                while ( fraccolleft >= fraccoltofill )
1159
                                {
1160
                                        if ( needcol )
1161
                                        {
1162
                                                ++nxP;
1163
                                                a = r = g = b = HALFSCALE;
1164
                                        }
1165
                                        a += fraccoltofill * qAlpha( *xP );
1166
                                        r += fraccoltofill * qRed( *xP );
1167
                                        g += fraccoltofill * qGreen( *xP );
1168
                                        b += fraccoltofill * qBlue( *xP );
1169
                                        r /= SCALE;
1170
                                        if ( r > maxval ) r = maxval;
1171
                                        g /= SCALE;
1172
                                        if ( g > maxval ) g = maxval;
1173
                                        b /= SCALE;
1174
                                        if ( b > maxval ) b = maxval;
1175
                                        a /= SCALE;
1176
                                        if ( a > maxval ) a = maxval;
1177
                                        *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
1178
                                        fraccolleft -= fraccoltofill;
1179
                                        fraccoltofill = SCALE;
1180
                                        needcol = 1;
1181
                                }
1182
                                if ( fraccolleft > 0 )
1183
                                {
1184
                                        if ( needcol )
1185
                                        {
1186
                                                ++nxP;
1187
                                                a = r = g = b = HALFSCALE;
1188
                                                needcol = 0;
1189
                                        }
1190
                                        a += fraccolleft * qAlpha( *xP );
1191
                                        r += fraccolleft * qRed( *xP );
1192
                                        g += fraccolleft * qGreen( *xP );
1193
                                        b += fraccolleft * qBlue( *xP );
1194
                                        fraccoltofill -= fraccolleft;
1195
                                }
1196
                        }
1197
                        if ( fraccoltofill > 0 )
1198
                        {
1199
                                --xP;
1200
                                a += fraccolleft * qAlpha( *xP );
1201
                                r += fraccoltofill * qRed( *xP );
1202
                                g += fraccoltofill * qGreen( *xP );
1203
                                b += fraccoltofill * qBlue( *xP );
1204
                        }
1205
                        if ( ! needcol )
1206
                        {
1207
                                r /= SCALE;
1208
                                if ( r > maxval ) r = maxval;
1209
                                g /= SCALE;
1210
                                if ( g > maxval ) g = maxval;
1211
                                b /= SCALE;
1212
                                if ( b > maxval ) b = maxval;
1213
                                a /= SCALE;
1214
                                if ( a > maxval ) a = maxval;
1215
                                *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
1216
                        }
1217
                }
1218
        }
1219
        if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
1220
                delete [] tempxelrow;
1221
        if ( as )                               // Avoid purify complaint
1222
                delete [] as;
1223
        if ( rs )                               // Robust, rs might be 0 one day
1224
                delete [] rs;
1225
        if ( gs )                               // Robust, gs might be 0 one day
1226
                delete [] gs;
1227
        if ( bs )                               // Robust, bs might be 0 one day
1228
                delete [] bs;
1229
        create(nwidth, nheight,32);
1230
        for( int yi=0; yi < dst.height(); ++yi )
1231
        {
1232
                QRgb *s = (QRgb*)(dst.scanLine( yi ));
1233
                QRgb *d = (QRgb*)(scanLine( yi ));
1234
                for(int xi=0; xi < dst.width(); ++xi )
1235
                {
1236
                        (*d) = (*s);
1237
                        s++;
1238
                        d++;
1239
                }
1240
        }
1241
        return;
1242
}
1243
 
5234 fschmid 1244
QByteArray ScImage::getAlpha(QString fn, bool PDF, bool pdf14, int gsRes)
2004 fschmid 1245
{
5234 fschmid 1246
        QByteArray retArray;
5937 jghali 1247
        ScImgDataLoader* pDataLoader = NULL;
2004 fschmid 1248
        short resolutionunit = 0;
1249
        imgInfo.valid = false;
1250
        imgInfo.clipPath = "";
1251
        imgInfo.PDSpathData.clear();
1252
        imgInfo.layerInfo.clear();
1253
        QFileInfo fi = QFileInfo(fn);
1254
        if (!fi.exists())
5234 fschmid 1255
                return retArray;
2995 fschmid 1256
        QString tmp, BBox, tmp2;
2004 fschmid 1257
        QString ext = fi.extension(false).lower();
2995 fschmid 1258
        if ((ext == "jpg") || (ext == "jpeg"))
5234 fschmid 1259
                return retArray;
2995 fschmid 1260
        bool found = false;
1261
        int retg = -1;
1262
        QChar tc;
5937 jghali 1263
 
2995 fschmid 1264
        if (ext == "pdf")
5937 jghali 1265
                pDataLoader = new ScImgDataLoader_PDF();
2995 fschmid 1266
        else if ((ext == "eps") || (ext == "ps"))
5937 jghali 1267
                pDataLoader = new ScImgDataLoader_PS();
1268
#ifdef HAVE_TIFF
1269
        else if ((ext == "tif") || (ext == "tiff"))
1270
                pDataLoader = new ScImgDataLoader_TIFF();
1271
#endif // HAVE_TIFF
1272
        else if (ext == "psd")
1273
                pDataLoader = new ScImgDataLoader_PSD();
1274
        else
1275
                pDataLoader = new ScImgDataLoader_QT();
1276
 
1277
        if      (pDataLoader)
2995 fschmid 1278
        {
5937 jghali 1279
                pDataLoader->preloadAlphaChannel(fn, gsRes);
1280
                QImage& rImage = pDataLoader->image();
1281
                if (rImage.isNull())
2995 fschmid 1282
                {
5937 jghali 1283
                        delete pDataLoader;
1284
                        return retArray;
2995 fschmid 1285
                }
5937 jghali 1286
                int i = 0;
1287
                unsigned char u;
1288
                int hm = rImage.height();
1289
                int wm = rImage.width();
1290
                int w2;
1291
                if (pdf14)
2995 fschmid 1292
                {
5937 jghali 1293
                        retArray.resize(hm * wm);
1294
                        for( int yi=0; yi < hm; ++yi )
2995 fschmid 1295
                        {
5937 jghali 1296
                                QRgb * s = (QRgb*)(rImage.scanLine( yi ));
1297
                                for( int xi=0; xi < wm; ++xi )
2995 fschmid 1298
                                {
5937 jghali 1299
                                        QRgb r=*s++;
1300
                                        u=qAlpha(r);
1301
                                        retArray[i++] = u;
2995 fschmid 1302
                                }
1303
                        }
1304
                }
5937 jghali 1305
                else
2004 fschmid 1306
                {
5937 jghali 1307
                        QImage iMask = rImage.createAlphaMask();
1308
                        hm = iMask.height();
1309
                        wm = iMask.width();
1310
                        w2 = wm / 8;
1311
                        if ((wm % 8) != 0)
1312
                                w2++;
1313
                        retArray.resize(hm * w2);
1314
                        for( int yi=0; yi < hm; ++yi )
2004 fschmid 1315
                        {
5937 jghali 1316
                                uchar * s = iMask.scanLine( yi );
1317
                                for( int xi=0; xi < w2; ++xi )
2004 fschmid 1318
                                {
5937 jghali 1319
                                        u = *(s+xi);
1320
                                        if(PDF) u = ~u;
1321
                                        retArray[i++] = u;
2004 fschmid 1322
                                }
1323
                        }
1324
                }
5937 jghali 1325
                delete pDataLoader;
2004 fschmid 1326
        }
5234 fschmid 1327
        return retArray;
2004 fschmid 1328
}
1329
 
4222 craig 1330
void ScImage::getEmbeddedProfile(const QString & fn, QString *profile, int *components)
3009 fschmid 1331
{
4222 craig 1332
        Q_ASSERT(profile);
1333
        Q_ASSERT(components);
5937 jghali 1334
        ScImgDataLoader* pDataLoader = NULL;
3009 fschmid 1335
#ifdef HAVE_CMS
5937 jghali 1336
        cmsHPROFILE prof = 0;
1337
 
1338
        profile->setLength(0);
1339
        *components = 0;
3009 fschmid 1340
        QFileInfo fi = QFileInfo(fn);
1341
        if (!fi.exists())
1342
                return;
1343
        QString ext = fi.extension(false).lower();
5937 jghali 1344
 
3009 fschmid 1345
        if (ext == "psd")
5937 jghali 1346
                pDataLoader = new ScImgDataLoader_PSD();
3009 fschmid 1347
#ifdef HAVE_TIFF
1348
        else if ((ext == "tif") || (ext == "tiff"))
5937 jghali 1349
                pDataLoader = new ScImgDataLoader_TIFF();
1350
#endif
3009 fschmid 1351
        else if ((ext == "jpg") || (ext == "jpeg"))
5937 jghali 1352
                pDataLoader = new ScImgDataLoader_JPEG();
1353
 
1354
        if      (pDataLoader)
3009 fschmid 1355
        {
5937 jghali 1356
                pDataLoader->loadEmbeddedProfile(fn);
1357
                QByteArray embeddedProfile = pDataLoader->embeddedProfile();
1358
                if      (embeddedProfile.size())
3009 fschmid 1359
                {
5937 jghali 1360
                        prof = cmsOpenProfileFromMem(embeddedProfile.data(), embeddedProfile.size());
1361
                        if (prof)
3009 fschmid 1362
                        {
5937 jghali 1363
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigRgbData)
3009 fschmid 1364
                                        *components = 3;
5937 jghali 1365
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigCmykData)
3009 fschmid 1366
                                        *components = 4;
5937 jghali 1367
                                for (uint el = 0; el < embeddedProfile.size(); ++el)
1368
                                        *profile += embeddedProfile[el];
3009 fschmid 1369
                        }
5937 jghali 1370
                        cmsCloseProfile(prof);
3009 fschmid 1371
                }
5937 jghali 1372
                delete pDataLoader;
3009 fschmid 1373
        }
1374
#endif // HAVE_CMS
1375
}
2004 fschmid 1376
 
5234 fschmid 1377
void ScImage::getEmbeddedProfile(const QString & fn, QByteArray *profile, int *components)
1378
{
1379
        Q_ASSERT(profile);
1380
        Q_ASSERT(components);
5937 jghali 1381
        ScImgDataLoader* pDataLoader = NULL;
5234 fschmid 1382
#ifdef HAVE_CMS
5937 jghali 1383
        cmsHPROFILE prof = 0;
1384
 
1385
        profile->resize(0);
1386
        *components = 0;
5234 fschmid 1387
        QFileInfo fi = QFileInfo(fn);
1388
        if (!fi.exists())
1389
                return;
1390
        QString ext = fi.extension(false).lower();
5937 jghali 1391
 
5234 fschmid 1392
        if (ext == "psd")
5937 jghali 1393
                pDataLoader = new ScImgDataLoader_PSD();
5234 fschmid 1394
#ifdef HAVE_TIFF
1395
        else if ((ext == "tif") || (ext == "tiff"))
5937 jghali 1396
                pDataLoader = new ScImgDataLoader_TIFF();
1397
#endif
5234 fschmid 1398
        else if ((ext == "jpg") || (ext == "jpeg"))
5937 jghali 1399
                pDataLoader = new ScImgDataLoader_JPEG();
1400
 
1401
        if      (pDataLoader)
5234 fschmid 1402
        {
5937 jghali 1403
                pDataLoader->loadEmbeddedProfile(fn);
1404
                QByteArray embeddedProfile = pDataLoader->embeddedProfile();
1405
                if      (embeddedProfile.size())
5234 fschmid 1406
                {
5937 jghali 1407
                        prof = cmsOpenProfileFromMem(embeddedProfile.data(), embeddedProfile.size());
1408
                        if (prof)
5234 fschmid 1409
                        {
5937 jghali 1410
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigRgbData)
5234 fschmid 1411
                                        *components = 3;
5937 jghali 1412
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigCmykData)
5234 fschmid 1413
                                        *components = 4;
5937 jghali 1414
                                *profile = embeddedProfile;
5234 fschmid 1415
                        }
5937 jghali 1416
                        cmsCloseProfile(prof);
5234 fschmid 1417
                }
5937 jghali 1418
                delete pDataLoader;
5234 fschmid 1419
        }
1420
#endif // HAVE_CMS
1421
}
1422
 
5781 cbradney 1423
bool ScImage::LoadPicture(const QString & fn, const CMSettings& cmSettings,
4222 craig 1424
                                                  int rend, bool useEmbedded, bool useProf,
5345 mrdocs 1425
                                                  RequestType requestType, int gsRes, bool *realCMYK)
2004 fschmid 1426
{
3685 fschmid 1427
        // requestType - 0: CMYK, 1: RGB, 2: RGB Proof 3 : RawData, 4: Thumbnail
2004 fschmid 1428
        // gsRes - is the resolution that ghostscript will render at
1429
        bool isCMYK = false;
1430
        bool ret = false;
1431
        if (realCMYK != 0)
1432
                *realCMYK = false;
1433
        bool bilevel = false;
1434
        short resolutionunit = 0;
5345 mrdocs 1435
        RequestType reqType = requestType;
2004 fschmid 1436
#ifdef HAVE_CMS
1437
        cmsHTRANSFORM xform = 0;
1438
        cmsHPROFILE inputProf = 0;
1439
        int cmsFlags = 0;
1440
#endif
5937 jghali 1441
        auto_ptr<ScImgDataLoader> pDataLoader;
2004 fschmid 1442
        QFileInfo fi = QFileInfo(fn);
1443
        if (!fi.exists())
1444
                return ret;
1445
        QString ext = fi.extension(false).lower();
1446
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
1447
        QChar tc;
1448
        bool found = false;
5937 jghali 1449
 
2004 fschmid 1450
        if (ext == "pdf")
5937 jghali 1451
                pDataLoader.reset( new ScImgDataLoader_PDF() );
1452
        else if ((ext == "eps") || (ext == "ps"))
1453
                pDataLoader.reset( new ScImgDataLoader_PS() );
2004 fschmid 1454
#ifdef HAVE_TIFF
1455
        else if ((ext == "tif") || (ext == "tiff"))
5937 jghali 1456
                pDataLoader.reset( new ScImgDataLoader_TIFF() );
2004 fschmid 1457
#endif // HAVE_TIFF
1458
        else if (ext == "psd")
5937 jghali 1459
                pDataLoader.reset( new ScImgDataLoader_PSD() );
2004 fschmid 1460
        else if ((ext == "jpg") || (ext == "jpeg"))
5937 jghali 1461
                pDataLoader.reset( new ScImgDataLoader_JPEG() );
1462
        else
1463
                pDataLoader.reset( new ScImgDataLoader_QT() );
1464
 
1465
        if      (pDataLoader->loadPicture(fn, gsRes, (requestType == Thumbnail)))
2004 fschmid 1466
        {
5937 jghali 1467
                *this = pDataLoader->image();
1468
                imgInfo = pDataLoader->imageInfoRecord();
1469
                if (requestType == Thumbnail)
1470
                        requestType = RGBData;
1471
                if (!cmSettings.useColorManagement() || !useProf)
2004 fschmid 1472
                {
3005 fschmid 1473
                        imgInfo.isEmbedded = false;
2004 fschmid 1474
                        imgInfo.profileName = "";
3005 fschmid 1475
                }
5937 jghali 1476
                if (imgInfo.colorspace == 1)
2004 fschmid 1477
                {
2742 fschmid 1478
                        isCMYK = true;
5937 jghali 1479
                        if(realCMYK)
1480
                                *realCMYK = true;
2742 fschmid 1481
                }
5937 jghali 1482
                pDataLoader->image() = QImage();
2004 fschmid 1483
        }
1484
        else
5937 jghali 1485
                return false;
1486
 
2004 fschmid 1487
        if (isNull())
1488
                return  ret;
5937 jghali 1489
 
2004 fschmid 1490
#ifdef HAVE_CMS
5937 jghali 1491
        QByteArray embeddedProfile = pDataLoader->embeddedProfile();
5788 jghali 1492
        if (cmSettings.useColorManagement() && useProf)
2004 fschmid 1493
        {
5937 jghali 1494
                if (embeddedProfile.size() > 0 )
1495
                {
1496
                        inputProf = cmsOpenProfileFromMem(embeddedProfile.data(), embeddedProfile.size());
1497
                }
2004 fschmid 1498
                else
1499
                {
3745 craig 1500
                        QCString profilePath;
5781 cbradney 1501
                        //CB If this is null, customfiledialog/picsearch/ScPreview might be sending it
1502
                        Q_ASSERT(cmSettings.doc()!=0);
2004 fschmid 1503
                        if (isCMYK)
2995 fschmid 1504
                        {
5781 cbradney 1505
                                if (ScCore->InputProfilesCMYK.contains(cmSettings.profileName()))
1506
                                        imgInfo.profileName = cmSettings.profileName();
3005 fschmid 1507
                                else
5781 cbradney 1508
                                        imgInfo.profileName = cmSettings.doc()->CMSSettings.DefaultImageCMYKProfile;
5243 cbradney 1509
                                profilePath = ScCore->InputProfilesCMYK[imgInfo.profileName].local8Bit();
2995 fschmid 1510
                        }
2004 fschmid 1511
                        else
2995 fschmid 1512
                        {
5781 cbradney 1513
                                if (ScCore->InputProfiles.contains(cmSettings.profileName()))
1514
                                        imgInfo.profileName = cmSettings.profileName();
3005 fschmid 1515
                                else
5781 cbradney 1516
                                        imgInfo.profileName = cmSettings.doc()->CMSSettings.DefaultImageRGBProfile;
5243 cbradney 1517
                                profilePath = ScCore->InputProfiles[imgInfo.profileName].local8Bit();
2995 fschmid 1518
                        }
3745 craig 1519
                        inputProf = cmsOpenProfileFromFile(profilePath.data(), "r");
2004 fschmid 1520
                }
1521
        }
5788 jghali 1522
        if (cmSettings.useColorManagement() && useProf && inputProf)
2004 fschmid 1523
        {
1524
                DWORD inputProfFormat = TYPE_RGBA_8;
5555 mrdocs 1525
                DWORD prnProfFormat = TYPE_CMYK_8;
1526
                int inputProfColorSpace = static_cast<int>(cmsGetColorSpace(inputProf));
1527
                if ( inputProfColorSpace == icSigRgbData )
2004 fschmid 1528
                        inputProfFormat = TYPE_RGBA_8;
5555 mrdocs 1529
                else if ( inputProfColorSpace == icSigCmykData )
2004 fschmid 1530
                        inputProfFormat = TYPE_CMYK_8;
5555 mrdocs 1531
                else if ( inputProfColorSpace == icSigGrayData )
1532
                        inputProfFormat = TYPE_GRAY_8;
5788 jghali 1533
                int prnProfColorSpace = static_cast<int>(cmsGetColorSpace(cmSettings.printerProfile()));
5555 mrdocs 1534
                if ( prnProfColorSpace == icSigRgbData )
1535
                        prnProfFormat = TYPE_RGBA_8;
1536
                else if ( prnProfColorSpace == icSigCmykData )
1537
                        prnProfFormat = TYPE_CMYK_8;
5788 jghali 1538
                if (cmSettings.doSoftProofing())
2004 fschmid 1539
                {
1540
                        cmsFlags |= cmsFLAGS_SOFTPROOFING;
5788 jghali 1541
                        if (cmSettings.doGamutCheck())
2004 fschmid 1542
                                cmsFlags |= cmsFLAGS_GAMUTCHECK;
1543
                }
5788 jghali 1544
                if (cmSettings.useBlackPoint())
2004 fschmid 1545
                        cmsFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
3685 fschmid 1546
                switch (reqType)
2004 fschmid 1547
                {
5345 mrdocs 1548
                case CMYKData: // CMYK
2004 fschmid 1549
                        if (!isCMYK)
5788 jghali 1550
                                xform = cmsCreateTransform(inputProf, inputProfFormat, cmSettings.printerProfile(), prnProfFormat, cmSettings.imageRenderingIntent(), 0);
5846 jghali 1551
                        if (prnProfColorSpace != icSigCmykData )
1552
                                *realCMYK = isCMYK = false;
2004 fschmid 1553
                        break;
5345 mrdocs 1554
                case RGBData: // RGB
2004 fschmid 1555
                        if (isCMYK)
5788 jghali 1556
                                xform = cmsCreateTransform(inputProf, inputProfFormat, cmSettings.monitorProfile(), TYPE_RGBA_8, rend, 0);
2004 fschmid 1557
                        break;
5345 mrdocs 1558
                case RGBProof: // RGB Proof
2004 fschmid 1559
                        {
5555 mrdocs 1560
                                if (inputProfFormat == TYPE_CMYK_8)
1561
                                        inputProfFormat = (COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1));//TYPE_YMCK_8;
1562
                                else if(inputProfFormat == TYPE_RGBA_8)
1563
                                        inputProfFormat = TYPE_BGRA_8;
5788 jghali 1564
                                if (cmSettings.doSoftProofing())
2095 fschmid 1565
                                        xform = cmsCreateProofingTransform(inputProf, inputProfFormat,
5788 jghali 1566
                                                                           cmSettings.monitorProfile(), TYPE_BGRA_8, cmSettings.printerProfile(),
5636 jghali 1567
                                                                           rend, INTENT_RELATIVE_COLORIMETRIC, cmsFlags);
2095 fschmid 1568
                                else
1569
                                        xform = cmsCreateTransform(inputProf, inputProfFormat,
5788 jghali 1570
                                                                   cmSettings.monitorProfile(), TYPE_BGRA_8, rend, cmsFlags);
2095 fschmid 1571
                        }
2004 fschmid 1572
                        break;
5345 mrdocs 1573
                case RawData: // no Conversion just raw Data
2004 fschmid 1574
                        xform = 0;
1575
                        break;
1576
                }
1577
                if (xform)
1578
                {
1579
                        for (int i = 0; i < height(); i++)
1580
                        {
1581
                                LPBYTE ptr = scanLine(i);
5555 mrdocs 1582
                                if ( inputProfFormat == TYPE_GRAY_8 && (reqType != CMYKData) )
1583
                                {
1584
                                        unsigned char* ucs = ptr + 1;
1585
                                        unsigned char* uc = new unsigned char[width()];
1586
                                        for( int uci = 0; uci < width(); uci++ )
1587
                                        {
1588
                                                uc[uci] = *ucs;
1589
                                                ucs += 4;
1590
                                        }
1591
                                        cmsDoTransform(xform, uc, ptr, width());
1592
                                        delete[] uc;
1593
                                }
1594
                                else if ( inputProfFormat == TYPE_GRAY_8 && (reqType == CMYKData) )
1595
                                {
1596
                                        unsigned char  value;
1597
                                        unsigned char* ucs = ptr;
1598
                                        for( int uci = 0; uci < width(); uci++ )
1599
                                        {
1600
                                                value = 255 - *(ucs + 1);
1601
                                                ucs[0] = ucs[1] = ucs[2] = 0;
1602
                                                ucs[3] = value;
1603
                                                ucs += 4;
1604
                                        }
1605
                                }
1606
                                else
1607
                                        cmsDoTransform(xform, ptr, ptr, width());
2004 fschmid 1608
                                // if transforming from CMYK to RGB, flatten the alpha channel
1609
                                // which will still contain the black channel
5345 mrdocs 1610
                                if (isCMYK && reqType != CMYKData && !bilevel)
2004 fschmid 1611
                                {
2633 cbradney 1612
                                        QRgb *p = (QRgb *) ptr;
1613
                                        QRgb alphaFF = qRgba(0,0,0,255);
2004 fschmid 1614
                                        for (int j = 0; j < width(); j++, p++)
2633 cbradney 1615
                                                *p |= alphaFF;
2004 fschmid 1616
                                }
1617
                        }
1618
                        cmsDeleteTransform (xform);
1619
                }
2995 fschmid 1620
                if (inputProf)
2004 fschmid 1621
                        cmsCloseProfile(inputProf);
1622
        }
1623
        else
1624
#endif // HAVE_CMS
1625
        {
3685 fschmid 1626
                switch (reqType)
2004 fschmid 1627
                {
5345 mrdocs 1628
                case CMYKData:
2004 fschmid 1629
                        if (!isCMYK)
1630
                        {
1631
                                for (int i = 0; i < height(); i++)
1632
                                {
2633 cbradney 1633
                                        QRgb *ptr = (QRgb *) scanLine(i);
2866 fschmid 1634
                                        unsigned char cc, cm, cy ,ck;
2004 fschmid 1635
                                        for (int j = 0; j < width(); j++)
1636
                                        {
2866 fschmid 1637
                                                cc = 255 - qRed(*ptr);
1638
                                                cm = 255 - qGreen(*ptr);
1639
                                                cy = 255 - qBlue(*ptr);
1640
                                                ck = QMIN(QMIN(cc, cm), cy);
1641
                                                *ptr++ = qRgba(cc-ck,cm-ck,cy-ck,ck);
2004 fschmid 1642
                                        }
1643
                                }
1644
                        }
1645
                        break;
5345 mrdocs 1646
                case RGBData:
1647
                case RGBProof:
2004 fschmid 1648
                        if (isCMYK)
1649
                        {
1650
                                for (int i = 0; i < height(); i++)
1651
                                {
2633 cbradney 1652
                                        QRgb *ptr = (QRgb *) scanLine(i);
2866 fschmid 1653
                                        unsigned char cr, cg, cb, ck;
2004 fschmid 1654
                                        for (int j = 0; j < width(); j++)
1655
                                        {
2866 fschmid 1656
                                                ck = qAlpha(*ptr);
1657
                                                cr = 255 - QMIN(255, qRed(*ptr) + ck);
1658
                                                cg = 255 - QMIN(255, qGreen(*ptr) + ck);
1659
                                                cb = 255 - QMIN(255, qBlue(*ptr) + ck);
1660
                                                *ptr++ = qRgba(cr,cg,cb,255);
2004 fschmid 1661
                                        }
1662
                                }
1663
                        }
1664
                        break;
5345 mrdocs 1665
                case RawData:
2004 fschmid 1666
                        break;
1667
                }
1668
        }
5345 mrdocs 1669
        if ((reqType == CMYKData || isCMYK) && !bilevel)
2004 fschmid 1670
                setAlphaBuffer(false);
4582 fschmid 1671
/*      setDotsPerMeterX (QMAX(2834, (int) (xres / 0.0254)));
2004 fschmid 1672
        setDotsPerMeterY (QMAX(2834, (int) (yres / 0.0254)));
2015 fschmid 1673
        imgInfo.xres = QMAX(72, qRound(xres));
4582 fschmid 1674
        imgInfo.yres = QMAX(72, qRound(yres)); */
2004 fschmid 1675
        return true;
1676
}