Subversion Repositories Scribus

Rev

Rev 8451 | 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"
6412 fschmid 11
#include "scimgdataloader_gimp.h"
5937 jghali 12
#include "scimgdataloader_jpeg.h"
13
#include "scimgdataloader_pdf.h"
14
#include "scimgdataloader_ps.h"
15
#include "scimgdataloader_psd.h"
16
#include "scimgdataloader_pdf.h"
17
#include "scimgdataloader_qt.h"
18
#include "scimgdataloader_tiff.h"
5977 jghali 19
#include <qmessagebox.h>
2074 fschmid 20
#include <qtextstream.h>
5937 jghali 21
#include <memory>
2125 cbradney 22
#include <cassert>
6566 fschmid 23
#include CMS_INC
24
#include "cmsutil.h"
4506 cbradney 25
#include "gsutil.h"
3685 fschmid 26
#include "exif.h"
4546 subik 27
#include "commonstrings.h"
6125 cbradney 28
#include "colorutil.h"
6808 fschmid 29
#include "util.h"
6835 fschmid 30
#include "rawimage.h"
7478 jghali 31
#include "sccolorengine.h"
2004 fschmid 32
 
5937 jghali 33
using namespace std;
34
 
2004 fschmid 35
typedef struct my_error_mgr
36
{
37
        struct jpeg_error_mgr pub;            /* "public" fields */
38
        jmp_buf setjmp_buffer;  /* for return to caller */
39
}
40
*my_error_ptr;
41
 
42
static void my_error_exit (j_common_ptr cinfo)
43
{
44
        my_error_ptr myerr = (my_error_ptr) cinfo->err;
45
        (*cinfo->err->output_message) (cinfo);
46
        longjmp (myerr->setjmp_buffer, 1);
47
}
48
 
4222 craig 49
ScImage::ScImage(const QImage & image) : QImage(image)
2004 fschmid 50
{
2012 fschmid 51
        initialize();
2004 fschmid 52
}
53
 
5593 avox 54
 
55
// ScImage will use implicit sharing:
56
ScImage::ScImage(const ScImage & image) : QImage(image.copy())
57
{
58
        initialize();
59
}
60
 
61
 
2004 fschmid 62
ScImage::ScImage() : QImage()
63
{
2012 fschmid 64
        initialize();
2004 fschmid 65
}
66
 
67
ScImage::ScImage( int width, int height ) : QImage( width, height, 32 )
68
{
2012 fschmid 69
        initialize();
70
}
71
 
5593 avox 72
const QImage& ScImage::qImage()
73
{
74
        return *this;
75
}
76
 
6063 fschmid 77
QImage* ScImage::qImagePtr()
78
{
79
        return this;
80
}
81
 
5593 avox 82
QImage ScImage::smoothScale(int h, int w, QImage::ScaleMode mode) const
83
{
84
        return QImage::smoothScale(h,w,mode);
85
}
86
 
87
 
2012 fschmid 88
void ScImage::initialize()
89
{
2004 fschmid 90
        imgInfo.xres = 72;
91
        imgInfo.yres = 72;
92
        imgInfo.colorspace = 0;
93
        imgInfo.valid = false;
94
        imgInfo.isRequest = false;
5567 mrdocs 95
        imgInfo.isEmbedded = false;
2004 fschmid 96
        imgInfo.progressive = false;
3703 fschmid 97
        imgInfo.exifDataValid = false;
2025 fschmid 98
        imgInfo.lowResType = 1;
99
        imgInfo.lowResScale = 1.0;
2004 fschmid 100
        imgInfo.PDSpathData.clear();
101
        imgInfo.RequestProps.clear();
102
        imgInfo.clipPath = "";
103
        imgInfo.usedPath = "";
104
        imgInfo.layerInfo.clear();
6085 fschmid 105
        imgInfo.duotoneColors.clear();
3703 fschmid 106
        imgInfo.exifInfo.cameraName = "";
107
        imgInfo.exifInfo.cameraVendor = "";
108
        imgInfo.exifInfo.thumbnail = QImage();
4331 fschmid 109
        imgInfo.BBoxX = 0;
110
        imgInfo.BBoxH = 0;
2004 fschmid 111
}
112
 
4050 cbradney 113
ScImage::~ScImage()
114
{
115
        curveTable.resize(0);
116
}
117
 
7478 jghali 118
void ScImage::applyEffect(QValueList<imageEffect> effectsList, ColorList& colors, bool cmyk)
2074 fschmid 119
{
7478 jghali 120
        ScribusDoc* doc = colors.document();
2074 fschmid 121
        if (effectsList.count() != 0)
122
        {
123
                for (uint a = 0; a < effectsList.count(); ++a)
124
                {
2082 fschmid 125
                        if ((*effectsList.at(a)).effectCode == EF_INVERT)
2074 fschmid 126
                                invert(cmyk);
2082 fschmid 127
                        if ((*effectsList.at(a)).effectCode == EF_GRAYSCALE)
2074 fschmid 128
                                toGrayscale(cmyk);
2082 fschmid 129
                        if ((*effectsList.at(a)).effectCode == EF_COLORIZE)
2074 fschmid 130
                        {
131
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
4546 subik 132
                                QString col = CommonStrings::None;
2074 fschmid 133
                                int shading = 100;
134
                                QTextStream fp(&tmpstr, IO_ReadOnly);
6798 jghali 135
                                fp >> col;
2074 fschmid 136
                                fp >> shading;
7478 jghali 137
                                colorize(doc, colors[col], shading, cmyk);
2074 fschmid 138
                        }
2082 fschmid 139
                        if ((*effectsList.at(a)).effectCode == EF_BRIGHTNESS)
140
                        {
141
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
142
                                int brightnessValue = 0;
143
                                QTextStream fp(&tmpstr, IO_ReadOnly);
144
                                fp >> brightnessValue;
145
                                brightness(brightnessValue, cmyk);
146
                        }
147
                        if ((*effectsList.at(a)).effectCode == EF_CONTRAST)
148
                        {
149
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
150
                                int contrastValue = 0;
151
                                QTextStream fp(&tmpstr, IO_ReadOnly);
152
                                fp >> contrastValue;
153
                                contrast(contrastValue, cmyk);
154
                        }
2092 fschmid 155
                        if ((*effectsList.at(a)).effectCode == EF_SHARPEN)
156
                        {
157
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
158
                                double radius, sigma;
159
                                QTextStream fp(&tmpstr, IO_ReadOnly);
160
                                fp >> radius;
161
                                fp >> sigma;
162
                                sharpen(radius, sigma);
163
                        }
2095 fschmid 164
                        if ((*effectsList.at(a)).effectCode == EF_BLUR)
165
                        {
166
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
167
                                double radius, sigma;
168
                                QTextStream fp(&tmpstr, IO_ReadOnly);
169
                                fp >> radius;
170
                                fp >> sigma;
6011 fschmid 171
                                blur(static_cast<int>(radius));
2095 fschmid 172
                        }
2096 fschmid 173
                        if ((*effectsList.at(a)).effectCode == EF_SOLARIZE)
174
                        {
175
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
176
                                double sigma;
177
                                QTextStream fp(&tmpstr, IO_ReadOnly);
178
                                fp >> sigma;
179
                                solarize(sigma, cmyk);
180
                        }
6080 fschmid 181
                        if ((*effectsList.at(a)).effectCode == EF_DUOTONE)
182
                        {
183
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
184
                                QString col1 = CommonStrings::None;
185
                                int shading1 = 100;
186
                                QString col2 = CommonStrings::None;
187
                                int shading2 = 100;
188
                                QTextStream fp(&tmpstr, IO_ReadOnly);
189
                                col1 = fp.readLine();
190
                                col2 = fp.readLine();
191
                                fp >> shading1;
192
                                fp >> shading2;
6129 fschmid 193
                                int numVals;
194
                                double xval, yval;
195
                                FPointArray curve1;
196
                                curve1.resize(0);
197
                                fp >> numVals;
198
                                for (int nv = 0; nv < numVals; nv++)
199
                                {
200
                                        fp >> xval;
201
                                        fp >> yval;
202
                                        curve1.addPoint(xval, yval);
203
                                }
6193 fschmid 204
                                int lin1;
205
                                fp >> lin1;
6129 fschmid 206
                                FPointArray curve2;
207
                                curve2.resize(0);
208
                                fp >> numVals;
209
                                for (int nv = 0; nv < numVals; nv++)
210
                                {
211
                                        fp >> xval;
212
                                        fp >> yval;
213
                                        curve2.addPoint(xval, yval);
214
                                }
6193 fschmid 215
                                int lin2;
216
                                fp >> lin2;
7478 jghali 217
                                duotone(doc, colors[col1], shading1, curve1, lin1, colors[col2], shading2, curve2, lin2, cmyk);
6080 fschmid 218
                        }
219
                        if ((*effectsList.at(a)).effectCode == EF_TRITONE)
220
                        {
221
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
222
                                QString col1 = CommonStrings::None;
223
                                QString col2 = CommonStrings::None;
224
                                QString col3 = CommonStrings::None;
225
                                int shading1 = 100;
226
                                int shading2 = 100;
227
                                int shading3 = 100;
228
                                QTextStream fp(&tmpstr, IO_ReadOnly);
229
                                col1 = fp.readLine();
230
                                col2 = fp.readLine();
231
                                col3 = fp.readLine();
232
                                fp >> shading1;
233
                                fp >> shading2;
234
                                fp >> shading3;
6129 fschmid 235
                                int numVals;
236
                                double xval, yval;
237
                                FPointArray curve1;
238
                                curve1.resize(0);
239
                                fp >> numVals;
240
                                for (int nv = 0; nv < numVals; nv++)
241
                                {
242
                                        fp >> xval;
243
                                        fp >> yval;
244
                                        curve1.addPoint(xval, yval);
245
                                }
6193 fschmid 246
                                int lin1;
247
                                fp >> lin1;
6129 fschmid 248
                                FPointArray curve2;
249
                                curve2.resize(0);
250
                                fp >> numVals;
251
                                for (int nv = 0; nv < numVals; nv++)
252
                                {
253
                                        fp >> xval;
254
                                        fp >> yval;
255
                                        curve2.addPoint(xval, yval);
256
                                }
6193 fschmid 257
                                int lin2;
258
                                fp >> lin2;
6129 fschmid 259
                                FPointArray curve3;
260
                                curve3.resize(0);
261
                                fp >> numVals;
262
                                for (int nv = 0; nv < numVals; nv++)
263
                                {
264
                                        fp >> xval;
265
                                        fp >> yval;
266
                                        curve3.addPoint(xval, yval);
267
                                }
6193 fschmid 268
                                int lin3;
269
                                fp >> lin3;
7478 jghali 270
                                tritone(doc, colors[col1], shading1, curve1, lin1, colors[col2], shading2, curve2, lin2, colors[col3], shading3, curve3, lin3, cmyk);
6080 fschmid 271
                        }
272
                        if ((*effectsList.at(a)).effectCode == EF_QUADTONE)
273
                        {
274
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
275
                                QString col1 = CommonStrings::None;
276
                                QString col2 = CommonStrings::None;
277
                                QString col3 = CommonStrings::None;
278
                                QString col4 = CommonStrings::None;
279
                                int shading1 = 100;
280
                                int shading2 = 100;
281
                                int shading3 = 100;
282
                                int shading4 = 100;
283
                                QTextStream fp(&tmpstr, IO_ReadOnly);
284
                                col1 = fp.readLine();
285
                                col2 = fp.readLine();
286
                                col3 = fp.readLine();
287
                                col4 = fp.readLine();
288
                                fp >> shading1;
289
                                fp >> shading2;
290
                                fp >> shading3;
291
                                fp >> shading4;
6129 fschmid 292
                                int numVals;
293
                                double xval, yval;
294
                                FPointArray curve1;
295
                                curve1.resize(0);
296
                                fp >> numVals;
297
                                for (int nv = 0; nv < numVals; nv++)
298
                                {
299
                                        fp >> xval;
300
                                        fp >> yval;
301
                                        curve1.addPoint(xval, yval);
302
                                }
6193 fschmid 303
                                int lin1;
304
                                fp >> lin1;
6129 fschmid 305
                                FPointArray curve2;
306
                                curve2.resize(0);
307
                                fp >> numVals;
308
                                for (int nv = 0; nv < numVals; nv++)
309
                                {
310
                                        fp >> xval;
311
                                        fp >> yval;
312
                                        curve2.addPoint(xval, yval);
313
                                }
6193 fschmid 314
                                int lin2;
315
                                fp >> lin2;
6129 fschmid 316
                                FPointArray curve3;
317
                                curve3.resize(0);
318
                                fp >> numVals;
319
                                for (int nv = 0; nv < numVals; nv++)
320
                                {
321
                                        fp >> xval;
322
                                        fp >> yval;
323
                                        curve3.addPoint(xval, yval);
324
                                }
6193 fschmid 325
                                int lin3;
326
                                fp >> lin3;
6129 fschmid 327
                                FPointArray curve4;
328
                                curve4.resize(0);
329
                                fp >> numVals;
330
                                for (int nv = 0; nv < numVals; nv++)
331
                                {
332
                                        fp >> xval;
333
                                        fp >> yval;
334
                                        curve4.addPoint(xval, yval);
335
                                }
6193 fschmid 336
                                int lin4;
337
                                fp >> lin4;
7478 jghali 338
                                quadtone(doc, colors[col1], shading1, curve1, lin1, colors[col2], shading2, curve2, lin2, colors[col3], shading3, curve3, lin3, colors[col4], shading4, curve4, lin4, cmyk);
6080 fschmid 339
                        }
6116 fschmid 340
                        if ((*effectsList.at(a)).effectCode == EF_GRADUATE)
341
                        {
342
                                QString tmpstr = (*effectsList.at(a)).effectParameters;
343
                                int numVals;
344
                                double xval, yval;
345
                                FPointArray curve;
346
                                curve.resize(0);
347
                                QTextStream fp(&tmpstr, IO_ReadOnly);
348
                                fp >> numVals;
349
                                for (int nv = 0; nv < numVals; nv++)
350
                                {
351
                                        fp >> xval;
352
                                        fp >> yval;
353
                                        curve.addPoint(xval, yval);
354
                                }
6193 fschmid 355
                                int lin;
356
                                fp >> lin;
357
                                doGraduate(curve, cmyk, lin);
6116 fschmid 358
                        }
2074 fschmid 359
                }
360
        }
361
}
8002 fschmid 362
/*
2095 fschmid 363
void ScImage::liberateMemory(void **memory)
364
{
365
        assert(memory != (void **)NULL);
366
        if(*memory == (void *)NULL)
367
                return;
368
        free(*memory);
369
        *memory=(void *) NULL;
370
}
8002 fschmid 371
*/
2096 fschmid 372
void ScImage::solarize(double factor, bool cmyk)
373
{
374
        curveTable.resize(256);
375
        int fk = qRound(255 / factor);
376
        for (int i = 0; i < 256; ++i)
377
        {
378
                curveTable[i] = QMIN(255, static_cast<int>(i / fk) * fk);
379
        }
380
        applyCurve(cmyk);
381
}
2095 fschmid 382
 
6011 fschmid 383
// Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>
384
void ScImage::blur(int radius)
385
{
386
    if (radius < 1) {
387
        return;
388
    }
2095 fschmid 389
 
6011 fschmid 390
    QRgb *pix = (QRgb*)bits();
391
    int w   = width();
392
    int h   = height();
393
    int wm  = w-1;
394
    int hm  = h-1;
395
    int wh  = w*h;
396
    int div = radius+radius+1;
397
 
398
    int *r = new int[wh];
399
    int *g = new int[wh];
400
    int *b = new int[wh];
401
    int *a = new int[wh];
402
    int rsum, gsum, bsum, asum, x, y, i, yp, yi, yw;
403
    QRgb p;
404
    int *vmin = new int[QMAX(w,h)];
405
 
406
    int divsum = (div+1)>>1;
407
    divsum *= divsum;
408
    int *dv = new int[256*divsum];
409
    for (i=0; i < 256*divsum; ++i) {
410
        dv[i] = (i/divsum);
411
    }
412
 
413
    yw = yi = 0;
414
 
415
    int **stack = new int*[div];
416
    for(int i = 0; i < div; ++i) {
417
        stack[i] = new int[4];
418
    }
419
 
420
 
421
    int stackpointer;
422
    int stackstart;
423
    int *sir;
424
    int rbs;
425
    int r1 = radius+1;
426
    int routsum, goutsum, boutsum, aoutsum;
427
    int rinsum, ginsum, binsum, ainsum;
428
 
429
    for (y = 0; y < h; ++y){
430
        rinsum = ginsum = binsum = ainsum
431
               = routsum = goutsum = boutsum = aoutsum
432
               = rsum = gsum = bsum = asum = 0;
433
        for(i =- radius; i <= radius; ++i) {
434
            p = pix[yi+QMIN(wm,QMAX(i,0))];
435
            sir = stack[i+radius];
436
            sir[0] = qRed(p);
437
            sir[1] = qGreen(p);
438
            sir[2] = qBlue(p);
439
            sir[3] = qAlpha(p);
440
 
441
            rbs = r1-abs(i);
442
            rsum += sir[0]*rbs;
443
            gsum += sir[1]*rbs;
444
            bsum += sir[2]*rbs;
445
            asum += sir[3]*rbs;
446
 
447
            if (i > 0){
448
                rinsum += sir[0];
449
                ginsum += sir[1];
450
                binsum += sir[2];
451
                ainsum += sir[3];
452
            } else {
453
                routsum += sir[0];
454
                goutsum += sir[1];
455
                boutsum += sir[2];
456
                aoutsum += sir[3];
457
            }
458
        }
459
        stackpointer = radius;
460
 
461
        for (x=0; x < w; ++x) {
462
 
463
            r[yi] = dv[rsum];
464
            g[yi] = dv[gsum];
465
            b[yi] = dv[bsum];
466
            a[yi] = dv[asum];
467
 
468
            rsum -= routsum;
469
            gsum -= goutsum;
470
            bsum -= boutsum;
471
            asum -= aoutsum;
472
 
473
            stackstart = stackpointer-radius+div;
474
            sir = stack[stackstart%div];
475
 
476
            routsum -= sir[0];
477
            goutsum -= sir[1];
478
            boutsum -= sir[2];
479
            aoutsum -= sir[3];
480
 
481
            if (y == 0) {
482
                vmin[x] = QMIN(x+radius+1,wm);
483
            }
484
            p = pix[yw+vmin[x]];
485
 
486
            sir[0] = qRed(p);
487
            sir[1] = qGreen(p);
488
            sir[2] = qBlue(p);
489
            sir[3] = qAlpha(p);
490
 
491
            rinsum += sir[0];
492
            ginsum += sir[1];
493
            binsum += sir[2];
494
            ainsum += sir[3];
495
 
496
            rsum += rinsum;
497
            gsum += ginsum;
498
            bsum += binsum;
499
            asum += ainsum;
500
 
501
            stackpointer = (stackpointer+1)%div;
502
            sir = stack[(stackpointer)%div];
503
 
504
            routsum += sir[0];
505
            goutsum += sir[1];
506
            boutsum += sir[2];
507
            aoutsum += sir[3];
508
 
509
            rinsum -= sir[0];
510
            ginsum -= sir[1];
511
            binsum -= sir[2];
512
            ainsum -= sir[3];
513
 
514
            ++yi;
515
        }
516
        yw += w;
517
    }
518
    for (x=0; x < w; ++x){
519
        rinsum = ginsum = binsum = ainsum
520
               = routsum = goutsum = boutsum = aoutsum
521
               = rsum = gsum = bsum = asum = 0;
522
 
523
        yp =- radius * w;
524
 
525
        for(i=-radius; i <= radius; ++i) {
526
            yi=QMAX(0,yp)+x;
527
 
528
            sir = stack[i+radius];
529
 
530
            sir[0] = r[yi];
531
            sir[1] = g[yi];
532
            sir[2] = b[yi];
533
            sir[3] = a[yi];
534
 
535
            rbs = r1-abs(i);
536
 
537
            rsum += r[yi]*rbs;
538
            gsum += g[yi]*rbs;
539
            bsum += b[yi]*rbs;
540
            asum += a[yi]*rbs;
541
 
542
            if (i > 0) {
543
                rinsum += sir[0];
544
                ginsum += sir[1];
545
                binsum += sir[2];
546
                ainsum += sir[3];
547
            } else {
548
                routsum += sir[0];
549
                goutsum += sir[1];
550
                boutsum += sir[2];
551
                aoutsum += sir[3];
552
            }
553
 
554
            if (i < hm){
555
                yp += w;
556
            }
557
        }
558
 
559
        yi = x;
560
        stackpointer = radius;
561
 
562
        for (y=0; y < h; ++y){
563
            pix[yi] = qRgba(dv[rsum], dv[gsum], dv[bsum], dv[asum]);
564
 
565
            rsum -= routsum;
566
            gsum -= goutsum;
567
            bsum -= boutsum;
568
            asum -= aoutsum;
569
 
570
            stackstart = stackpointer-radius+div;
571
            sir = stack[stackstart%div];
572
 
573
            routsum -= sir[0];
574
            goutsum -= sir[1];
575
            boutsum -= sir[2];
576
            aoutsum -= sir[3];
577
 
578
            if (x==0){
579
                vmin[y] = QMIN(y+r1,hm)*w;
580
            }
581
            p = x+vmin[y];
582
 
583
            sir[0] = r[p];
584
            sir[1] = g[p];
585
            sir[2] = b[p];
586
            sir[3] = a[p];
587
 
588
            rinsum += sir[0];
589
            ginsum += sir[1];
590
            binsum += sir[2];
591
            ainsum += sir[3];
592
 
593
            rsum += rinsum;
594
            gsum += ginsum;
595
            bsum += binsum;
596
            asum += ainsum;
597
 
598
            stackpointer = (stackpointer+1)%div;
599
            sir = stack[stackpointer];
600
 
601
            routsum += sir[0];
602
            goutsum += sir[1];
603
            boutsum += sir[2];
604
            aoutsum += sir[3];
605
 
606
            rinsum -= sir[0];
607
            ginsum -= sir[1];
608
            binsum -= sir[2];
609
            ainsum -= sir[3];
610
 
611
            yi += w;
612
        }
613
    }
614
    delete [] r;
615
    delete [] g;
616
    delete [] b;
617
    delete [] a;
618
    delete [] vmin;
619
    delete [] dv;
620
 
621
    for(int i = 0; i < div; ++i) {
622
        delete [] stack[i];
623
    }
624
    delete [] stack;
625
}
6116 fschmid 626
 
2092 fschmid 627
bool ScImage::convolveImage(QImage *dest, const unsigned int order, const double *kernel)
628
{
629
        long widthk;
630
        double red, green, blue, alpha;
631
        double normalize, *normal_kernel;
632
        register const double *k;
633
        register unsigned int *q;
634
        int x, y, mx, my, sx, sy;
635
        long i;
636
        int mcx, mcy;
637
        widthk = order;
638
        if((widthk % 2) == 0)
639
                return(false);
640
        normal_kernel = (double *)malloc(widthk*widthk*sizeof(double));
641
        if(!normal_kernel)
642
                return(false);
643
        dest->reset();
644
        dest->create(width(), height(), 32);
645
        normalize=0.0;
646
        for(i=0; i < (widthk*widthk); i++)
647
                normalize += kernel[i];
648
        if(fabs(normalize) <= 1.0e-12)
649
                normalize=1.0;
650
        normalize=1.0/normalize;
651
        for(i=0; i < (widthk*widthk); i++)
652
                normal_kernel[i] = normalize*kernel[i];
653
        unsigned int **jumpTablek = (unsigned int **)jumpTable();
654
        for(y=0; y < dest->height(); ++y)
655
        {
656
                sy = y-(widthk/2);
657
                q = (unsigned int *)dest->scanLine(y);
658
                for(x=0; x < dest->width(); ++x)
659
                {
660
                        k = normal_kernel;
661
                        red = green = blue = alpha = 0;
662
                        sy = y-(widthk/2);
663
                        for(mcy=0; mcy < widthk; ++mcy, ++sy)
664
                        {
665
                                my = sy < 0 ? 0 : sy > height()-1 ? height()-1 : sy;
666
                                sx = x+(-widthk/2);
667
                                for(mcx=0; mcx < widthk; ++mcx, ++sx)
668
                                {
669
                                        mx = sx < 0 ? 0 : sx > width()-1 ? width()-1 : sx;
670
                                        red += (*k)*(qRed(jumpTablek[my][mx])*257);
671
                                        green += (*k)*(qGreen(jumpTablek[my][mx])*257);
672
                                        blue += (*k)*(qBlue(jumpTablek[my][mx])*257);
673
                                        alpha += (*k)*(qAlpha(jumpTablek[my][mx])*257);
674
                                        ++k;
675
                                }
676
                        }
677
                        red = red < 0 ? 0 : red > 65535 ? 65535 : red+0.5;
678
                        green = green < 0 ? 0 : green > 65535 ? 65535 : green+0.5;
679
                        blue = blue < 0 ? 0 : blue > 65535 ? 65535 : blue+0.5;
680
                        alpha = alpha < 0 ? 0 : alpha > 65535 ? 65535 : alpha+0.5;
681
                        *q++ = qRgba((unsigned char)(red/257UL),
2095 fschmid 682
                                     (unsigned char)(green/257UL),
683
                                     (unsigned char)(blue/257UL),
684
                                     (unsigned char)(alpha/257UL));
2092 fschmid 685
                }
686
        }
2095 fschmid 687
        free(normal_kernel);
2092 fschmid 688
        return(true);
689
}
690
 
691
int ScImage::getOptimalKernelWidth(double radius, double sigma)
692
{
693
        double normalize, value;
694
        long width;
695
        register long u;
696
        assert(sigma != 0.0);
697
        if(radius > 0.0)
698
                return((int)(2.0*ceil(radius)+1.0));
699
        for(width=5; ;)
700
        {
701
                normalize=0.0;
702
                for(u=(-width/2); u <= (width/2); u++)
703
                        normalize+=exp(-((double) u*u)/(2.0*sigma*sigma))/(2.50662827463100024161235523934010416269302368164062*sigma);
704
                u=width/2;
705
                value=exp(-((double) u*u)/(2.0*sigma*sigma))/(2.50662827463100024161235523934010416269302368164062*sigma)/normalize;
706
                if((long)(65535*value) <= 0)
707
                        break;
708
                width+=2;
709
        }
710
        return((int)width-2);
711
}
712
 
713
void ScImage::sharpen(double radius, double sigma)
714
{
715
        double alpha, normalize, *kernel;
716
        int widthk;
717
        register long i, u, v;
718
        QImage dest;
719
        if(sigma == 0.0)
720
                return;
721
        widthk = getOptimalKernelWidth(radius, sigma);
722
        if(width() < widthk)
723
                return;
724
        kernel = (double *)malloc(widthk*widthk*sizeof(double));
725
        if(!kernel)
726
                return;
727
        i = 0;
728
        normalize=0.0;
729
        for (v=(-widthk/2); v <= (widthk/2); v++)
730
        {
731
                for (u=(-widthk/2); u <= (widthk/2); u++)
732
                {
733
                        alpha=exp(-((double) u*u+v*v)/(2.0*sigma*sigma));
734
                        kernel[i]=alpha/(2.0*3.14159265358979323846264338327950288419716939937510*sigma*sigma);
735
                        normalize+=kernel[i];
736
                        i++;
737
                }
738
        }
739
        kernel[i/2]=(-2.0)*normalize;
740
        convolveImage(&dest, widthk, kernel);
8002 fschmid 741
        free(kernel);
742
//      liberateMemory((void **) &kernel);
2092 fschmid 743
        for( int yi=0; yi < dest.height(); ++yi )
744
        {
745
                QRgb *s = (QRgb*)(dest.scanLine( yi ));
746
                QRgb *d = (QRgb*)(scanLine( yi ));
747
                for(int xi=0; xi < dest.width(); ++xi )
748
                {
749
                        (*d) = (*s);
750
                        s++;
751
                        d++;
752
                }
753
        }
754
        return;
755
}
756
 
2082 fschmid 757
void ScImage::contrast(int contrastValue, bool cmyk)
758
{
759
        curveTable.resize(256);
760
        QPoint p1(0,0 - contrastValue);
761
        QPoint p2(256, 256 + contrastValue);
762
        double mc = (p1.y() - p2.y()) / (double)(p1.x() - p2.x());
763
        for (int i = 0; i < 256; ++i)
764
        {
765
                curveTable[i] = QMIN(255, QMAX(0, int(i * mc) + p1.y()));
766
        }
767
        applyCurve(cmyk);
768
}
769
 
770
void ScImage::brightness(int brightnessValue, bool cmyk)
771
{
772
        curveTable.resize(256);
773
        QPoint p1(0,0 + brightnessValue);
774
        QPoint p2(256, 256 + brightnessValue);
775
        double mc = (p1.y() - p2.y()) / (double)(p1.x() - p2.x());
776
        for (int i = 0; i < 256; ++i)
777
        {
778
                curveTable[i] = QMIN(255, QMAX(0, int(i * mc) + p1.y()));
779
        }
780
        applyCurve(cmyk);
781
}
782
 
6193 fschmid 783
void ScImage::doGraduate(FPointArray curve, bool cmyk, bool linear)
6116 fschmid 784
{
785
        curveTable.resize(256);
786
        for (int x = 0 ; x < 256 ; x++)
787
        {
6193 fschmid 788
                curveTable[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve, x / 255.0, linear) * 255)));
6116 fschmid 789
        }
790
        applyCurve(cmyk);
791
}
792
 
2082 fschmid 793
void ScImage::applyCurve(bool cmyk)
794
{
795
        int h = height();
796
        int w = width();
7175 fschmid 797
        QRgb *s;
798
        QRgb r;
799
        int c, m, y, k;
800
        unsigned char *p;
801
        unsigned char rc, gc, bc;
2082 fschmid 802
        for( int yi=0; yi < h; ++yi )
803
        {
7175 fschmid 804
                s = (QRgb*)(scanLine( yi ));
2082 fschmid 805
                for( int xi=0; xi < w; ++xi )
806
                {
7175 fschmid 807
                        r = *s;
2082 fschmid 808
                        if (cmyk)
809
                        {
7175 fschmid 810
                                p = (unsigned char *) s;
811
                                rc = 255 - QMIN(255, p[0] + p[3]);
812
                                gc = 255 - QMIN(255, p[1] + p[3]);
813
                                bc = 255 - QMIN(255, p[2] + p[3]);
4419 cbradney 814
                                c = 255 - curveTable[(int)rc];
815
                                m = 255 - curveTable[(int)gc];
816
                                y = 255 - curveTable[(int)bc];
2082 fschmid 817
                                k = QMIN(QMIN(c, m), y);
818
                                *s = qRgba(y - k, m - k, c - k, k );
819
                        }
820
                        else
821
                        {
822
                                c = curveTable[qRed(r)];
823
                                m = curveTable[qGreen(r)];
824
                                y = curveTable[qBlue(r)];
825
                                k = qAlpha(r);
826
                                *s = qRgba(c, m, y, k);
827
                        }
828
                        s++;
829
                }
830
        }
831
}
832
 
7478 jghali 833
void ScImage::colorize(ScribusDoc* doc, ScColor color, int shade, bool cmyk)
2053 fschmid 834
{
835
        int h = height();
836
        int w = width();
837
        int cc, cm, cy, ck;
2057 fschmid 838
        int hu, sa, v;
2886 fschmid 839
        ScColor tmp2;
2057 fschmid 840
        QColor tmpR;
7175 fschmid 841
        QRgb *s;
842
        QRgb r;
843
        double k;
844
        int cc2, cm2, cy2, k2;
2053 fschmid 845
        if (cmyk)
7478 jghali 846
        {
847
                CMYKColor cmykCol;
848
                ScColorEngine::getShadeColorCMYK(color, doc, cmykCol, shade);
849
                cmykCol.getValues(cc, cm, cy, ck);
850
        }
2053 fschmid 851
        else
852
        {
853
                ck = 0;
7478 jghali 854
                RGBColor rgbCol;
855
                ScColorEngine::getShadeColorRGB(color, doc, rgbCol, shade);
856
                rgbCol.getValues(cc, cm, cy);
2053 fschmid 857
        }
858
        for( int yi=0; yi < h; ++yi )
859
        {
7175 fschmid 860
                s = (QRgb*)(scanLine( yi ));
2053 fschmid 861
                for( int xi=0; xi < w; ++xi )
862
                {
7175 fschmid 863
                        r = *s;
2053 fschmid 864
                        if (cmyk)
865
                        {
7175 fschmid 866
                                k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255) / 255.0;
2053 fschmid 867
                                *s = qRgba(QMIN(qRound(cc*k), 255), QMIN(qRound(cm*k), 255), QMIN(qRound(cy*k), 255), QMIN(qRound(ck*k), 255));
868
                        }
869
                        else
870
                        {
7175 fschmid 871
                                k2 = 255 - QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
2057 fschmid 872
                                tmpR.setRgb(cc, cm, cy);
873
                                tmpR.hsv(&hu, &sa, &v);
7175 fschmid 874
                                tmpR.setHsv(hu, sa * k2 / 255, 255 - ((255 - v) * k2 / 255));
2057 fschmid 875
                                tmpR.getRgb(&cc2, &cm2, &cy2);
7175 fschmid 876
                                *s = qRgba(cc2, cm2, cy2, qAlpha(r));
2053 fschmid 877
                        }
878
                        s++;
879
                }
880
        }
881
}
882
 
7478 jghali 883
void ScImage::duotone(ScribusDoc* doc, ScColor color1, int shade1, FPointArray curve1, bool lin1, ScColor color2, int shade2, FPointArray curve2, bool lin2, bool cmyk)
6080 fschmid 884
{
885
        int h = height();
886
        int w = width();
887
        int c, c1, m, m1, y, y1, k, k1;
888
        int cn, c1n, mn, m1n, yn, y1n, kn, k1n;
889
        uchar cb;
6129 fschmid 890
        QMemArray<int> curveTable1;
891
        QMemArray<int> curveTable2;
7478 jghali 892
        CMYKColor cmykCol;
893
        ScColorEngine::getShadeColorCMYK(color1, doc, cmykCol, shade1);
894
        cmykCol.getValues(c, m, y, k);
895
        ScColorEngine::getShadeColorCMYK(color2, doc, cmykCol, shade2);
896
        cmykCol.getValues(c1, m1, y1, k1);
6129 fschmid 897
        curveTable1.resize(256);
898
        for (int x = 0 ; x < 256 ; x++)
899
        {
6193 fschmid 900
                curveTable1[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve1, x / 255.0, lin1) * 255)));
6129 fschmid 901
        }
902
        curveTable2.resize(256);
903
        for (int x = 0 ; x < 256 ; x++)
904
        {
6193 fschmid 905
                curveTable2[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve2, x / 255.0, lin2) * 255)));
6129 fschmid 906
        }
6080 fschmid 907
        for( int yi=0; yi < h; ++yi )
908
        {
909
                QRgb * s = (QRgb*)(scanLine( yi ));
910
                for( int xi=0; xi < w; ++xi )
911
                {
912
                        QRgb r=*s;
913
                        if (cmyk)
914
                                cb = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255);
915
                        else
916
                                cb = 255 - QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
6129 fschmid 917
                        cn = QMIN((c * curveTable1[(int)cb]) >> 8, 255);
918
                        mn = QMIN((m * curveTable1[(int)cb]) >> 8, 255);
919
                        yn = QMIN((y * curveTable1[(int)cb]) >> 8, 255);
920
                        kn = QMIN((k * curveTable1[(int)cb]) >> 8, 255);
921
                        c1n = QMIN((c1 * curveTable1[(int)cb]) >> 8, 255);
922
                        m1n = QMIN((m1 * curveTable2[(int)cb]) >> 8, 255);
923
                        y1n = QMIN((y1 * curveTable2[(int)cb]) >> 8, 255);
924
                        k1n = QMIN((k1 * curveTable2[(int)cb]) >> 8, 255);
6080 fschmid 925
                        ScColor col = ScColor(QMIN(cn+c1n, 255), QMIN(mn+m1n, 255), QMIN(yn+y1n, 255), QMIN(kn+k1n, 255));
926
                        if (cmyk)
927
                                col.getCMYK(&cn, &mn, &yn, &kn);
928
                        else
929
                        {
930
                                col.getRawRGBColor(&cn, &mn, &yn);
931
                                kn = qAlpha(r);
932
                        }
933
                        *s = qRgba(cn, mn, yn, kn);
934
                        s++;
935
                }
936
        }
937
}
938
 
7478 jghali 939
void ScImage::tritone(ScribusDoc* doc, ScColor color1, int shade1, FPointArray curve1, bool lin1, ScColor color2, int shade2, FPointArray curve2, bool lin2, ScColor color3, int shade3, FPointArray curve3, bool lin3, bool cmyk)
6080 fschmid 940
{
941
        int h = height();
942
        int w = width();
943
        int c, c1, c2, m, m1, m2, y, y1, y2, k, k1, k2;
944
        int cn, c1n, c2n, mn, m1n, m2n, yn, y1n, y2n, kn, k1n, k2n;
945
        uchar cb;
7478 jghali 946
        CMYKColor cmykCol;
6129 fschmid 947
        QMemArray<int> curveTable1;
948
        QMemArray<int> curveTable2;
949
        QMemArray<int> curveTable3;
7478 jghali 950
        ScColorEngine::getShadeColorCMYK(color1, doc, cmykCol, shade1);
951
        cmykCol.getValues(c, m, y, k);
952
        ScColorEngine::getShadeColorCMYK(color2, doc, cmykCol, shade2);
953
        cmykCol.getValues(c1, m1, y1, k1);
954
        ScColorEngine::getShadeColorCMYK(color3, doc, cmykCol, shade3);
955
        cmykCol.getValues(c2, m2, y2, k2);
6129 fschmid 956
        curveTable1.resize(256);
957
        for (int x = 0 ; x < 256 ; x++)
958
        {
6193 fschmid 959
                curveTable1[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve1, x / 255.0, lin1) * 255)));
6129 fschmid 960
        }
961
        curveTable2.resize(256);
962
        for (int x = 0 ; x < 256 ; x++)
963
        {
6193 fschmid 964
                curveTable2[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve2, x / 255.0, lin2) * 255)));
6129 fschmid 965
        }
966
        curveTable3.resize(256);
967
        for (int x = 0 ; x < 256 ; x++)
968
        {
6193 fschmid 969
                curveTable3[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve2, x / 255.0, lin3) * 255)));
6129 fschmid 970
        }
6080 fschmid 971
        for( int yi=0; yi < h; ++yi )
972
        {
973
                QRgb * s = (QRgb*)(scanLine( yi ));
974
                for( int xi=0; xi < w; ++xi )
975
                {
976
                        QRgb r=*s;
977
                        if (cmyk)
978
                                cb = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255);
979
                        else
980
                                cb = 255 - QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
6129 fschmid 981
                        cn = QMIN((c * curveTable1[(int)cb]) >> 8, 255);
982
                        mn = QMIN((m * curveTable1[(int)cb]) >> 8, 255);
983
                        yn = QMIN((y * curveTable1[(int)cb]) >> 8, 255);
984
                        kn = QMIN((k * curveTable1[(int)cb]) >> 8, 255);
985
                        c1n = QMIN((c1 * curveTable2[(int)cb]) >> 8, 255);
986
                        m1n = QMIN((m1 * curveTable2[(int)cb]) >> 8, 255);
987
                        y1n = QMIN((y1 * curveTable2[(int)cb]) >> 8, 255);
988
                        k1n = QMIN((k1 * curveTable2[(int)cb]) >> 8, 255);
989
                        c2n = QMIN((c2 * curveTable3[(int)cb]) >> 8, 255);
990
                        m2n = QMIN((m2 * curveTable3[(int)cb]) >> 8, 255);
991
                        y2n = QMIN((y2 * curveTable3[(int)cb]) >> 8, 255);
992
                        k2n = QMIN((k2 * curveTable3[(int)cb]) >> 8, 255);
6080 fschmid 993
                        ScColor col = ScColor(QMIN(cn+c1n+c2n, 255), QMIN(mn+m1n+m2n, 255), QMIN(yn+y1n+y2n, 255), QMIN(kn+k1n+k2n, 255));
994
                        if (cmyk)
995
                                col.getCMYK(&cn, &mn, &yn, &kn);
996
                        else
997
                        {
998
                                col.getRawRGBColor(&cn, &mn, &yn);
999
                                kn = qAlpha(r);
1000
                        }
1001
                        *s = qRgba(cn, mn, yn, kn);
1002
                        s++;
1003
                }
1004
        }
1005
}
1006
 
7478 jghali 1007
void ScImage::quadtone(ScribusDoc* doc, ScColor color1, int shade1, FPointArray curve1, bool lin1, ScColor color2, int shade2, FPointArray curve2, bool lin2, ScColor color3, int shade3, FPointArray curve3, bool lin3, ScColor color4, int shade4, FPointArray curve4, bool lin4, bool cmyk)
6080 fschmid 1008
{
1009
        int h = height();
1010
        int w = width();
1011
        int c, c1, c2, c3, m, m1, m2, m3, y, y1, y2, y3, k, k1, k2, k3;
1012
        int cn, c1n, c2n, c3n, mn, m1n, m2n, m3n, yn, y1n, y2n, y3n, kn, k1n, k2n, k3n;
1013
        uchar cb;
7478 jghali 1014
        CMYKColor cmykCol;
6129 fschmid 1015
        QMemArray<int> curveTable1;
1016
        QMemArray<int> curveTable2;
1017
        QMemArray<int> curveTable3;
1018
        QMemArray<int> curveTable4;
7478 jghali 1019
        ScColorEngine::getShadeColorCMYK(color1, doc, cmykCol, shade1);
1020
        cmykCol.getValues(c, m, y, k);
1021
        ScColorEngine::getShadeColorCMYK(color2, doc, cmykCol, shade2);
1022
        cmykCol.getValues(c1, m1, y1, k1);
1023
        ScColorEngine::getShadeColorCMYK(color3, doc, cmykCol, shade3);
1024
        cmykCol.getValues(c2, m2, y2, k2);
1025
        ScColorEngine::getShadeColorCMYK(color4, doc, cmykCol, shade4);
1026
        cmykCol.getValues(c3, m3, y3, k3);
6129 fschmid 1027
        curveTable1.resize(256);
1028
        for (int x = 0 ; x < 256 ; x++)
1029
        {
6193 fschmid 1030
                curveTable1[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve1, x / 255.0, lin1) * 255)));
6129 fschmid 1031
        }
1032
        curveTable2.resize(256);
1033
        for (int x = 0 ; x < 256 ; x++)
1034
        {
6193 fschmid 1035
                curveTable2[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve2, x / 255.0, lin2) * 255)));
6129 fschmid 1036
        }
1037
        curveTable3.resize(256);
1038
        for (int x = 0 ; x < 256 ; x++)
1039
        {
6193 fschmid 1040
                curveTable3[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve3, x / 255.0, lin3) * 255)));
6129 fschmid 1041
        }
1042
        curveTable4.resize(256);
1043
        for (int x = 0 ; x < 256 ; x++)
1044
        {
6193 fschmid 1045
                curveTable4[x] = QMIN(255, QMAX(0, qRound(getCurveYValue(curve4, x / 255.0, lin4) * 255)));
6129 fschmid 1046
        }
6080 fschmid 1047
        for( int yi=0; yi < h; ++yi )
1048
        {
1049
                QRgb * s = (QRgb*)(scanLine( yi ));
1050
                for( int xi=0; xi < w; ++xi )
1051
                {
1052
                        QRgb r=*s;
1053
                        if (cmyk)
1054
                                cb = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255);
1055
                        else
1056
                                cb = 255 - QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
6129 fschmid 1057
                        cn = QMIN((c * curveTable1[(int)cb]) >> 8, 255);
1058
                        mn = QMIN((m * curveTable1[(int)cb]) >> 8, 255);
1059
                        yn = QMIN((y * curveTable1[(int)cb]) >> 8, 255);
1060
                        kn = QMIN((k * curveTable1[(int)cb]) >> 8, 255);
1061
                        c1n = QMIN((c1 * curveTable2[(int)cb]) >> 8, 255);
1062
                        m1n = QMIN((m1 * curveTable2[(int)cb]) >> 8, 255);
1063
                        y1n = QMIN((y1 * curveTable2[(int)cb]) >> 8, 255);
1064
                        k1n = QMIN((k1 * curveTable2[(int)cb]) >> 8, 255);
1065
                        c2n = QMIN((c2 * curveTable3[(int)cb]) >> 8, 255);
1066
                        m2n = QMIN((m2 * curveTable3[(int)cb]) >> 8, 255);
1067
                        y2n = QMIN((y2 * curveTable3[(int)cb]) >> 8, 255);
1068
                        k2n = QMIN((k2 * curveTable3[(int)cb]) >> 8, 255);
1069
                        c3n = QMIN((c3 * curveTable4[(int)cb]) >> 8, 255);
1070
                        m3n = QMIN((m3 * curveTable4[(int)cb]) >> 8, 255);
1071
                        y3n = QMIN((y3 * curveTable4[(int)cb]) >> 8, 255);
1072
                        k3n = QMIN((k3 * curveTable4[(int)cb]) >> 8, 255);
6080 fschmid 1073
                        ScColor col = ScColor(QMIN(cn+c1n+c2n+c3n, 255), QMIN(mn+m1n+m2n+m3n, 255), QMIN(yn+y1n+y2n+y3n, 255), QMIN(kn+k1n+k2n+k3n, 255));
1074
                        if (cmyk)
1075
                                col.getCMYK(&cn, &mn, &yn, &kn);
1076
                        else
1077
                        {
1078
                                col.getRawRGBColor(&cn, &mn, &yn);
1079
                                kn = qAlpha(r);
1080
                        }
1081
                        *s = qRgba(cn, mn, yn, kn);
1082
                        s++;
1083
                }
1084
        }
1085
}
1086
 
2057 fschmid 1087
void ScImage::invert(bool cmyk)
1088
{
1089
        int h = height();
1090
        int w = width();
7175 fschmid 1091
        unsigned char *p;
1092
        QRgb * s;
1093
        unsigned char c, m, y, k;
2057 fschmid 1094
        for( int yi=0; yi < h; ++yi )
1095
        {
7175 fschmid 1096
                s = (QRgb*)(scanLine( yi ));
2057 fschmid 1097
                for( int xi=0; xi < w; ++xi )
1098
                {
1099
                        if (cmyk)
1100
                        {
7175 fschmid 1101
                                p = (unsigned char *) s;
2766 cbradney 1102
                                c = 255 - QMIN(255, p[0] + p[3]);
1103
                                m = 255 - QMIN(255, p[1] + p[3]);
1104
                                y = 255 - QMIN(255, p[2] + p[3]);
2061 fschmid 1105
                                k = QMIN(QMIN(c, m), y);
2766 cbradney 1106
                                p[0] = c - k;
1107
                                p[1] = m - k;
1108
                                p[2] = y - k;
1109
                                p[3] = k;
2057 fschmid 1110
                        }
1111
                        else
2766 cbradney 1112
                                *s ^= 0x00ffffff;
2057 fschmid 1113
                        s++;
1114
                }
1115
        }
1116
}
1117
 
2053 fschmid 1118
void ScImage::toGrayscale(bool cmyk)
1119
{
1120
        int h = height();
1121
        int w = width();
7175 fschmid 1122
        int k;
1123
        QRgb * s;
1124
        QRgb r;
2053 fschmid 1125
        for( int yi=0; yi < h; ++yi )
1126
        {
7175 fschmid 1127
                s = (QRgb*)(scanLine( yi ));
2053 fschmid 1128
                for( int xi=0; xi < w; ++xi )
1129
                {
7175 fschmid 1130
                        r = *s;
2053 fschmid 1131
                        if (cmyk)
1132
                        {
2056 fschmid 1133
                                k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r) + qAlpha(r)), 255);
2053 fschmid 1134
                                *s = qRgba(0, 0, 0, k);
1135
                        }
1136
                        else
1137
                        {
1138
                                k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
7175 fschmid 1139
                                *s = qRgba(k, k, k, qAlpha(r));
2053 fschmid 1140
                        }
1141
                        s++;
1142
                }
1143
        }
1144
}
1145
 
2012 fschmid 1146
void ScImage::swapRGBA()
1147
{
7175 fschmid 1148
        unsigned int *ptr;
1149
        unsigned char *p;
1150
        unsigned char r, b;
2012 fschmid 1151
        for (int i = 0; i < height(); ++i)
1152
        {
7175 fschmid 1153
                ptr = (unsigned int *) scanLine(i);
2012 fschmid 1154
                for (int j = 0; j < width(); ++j)
1155
                {
7175 fschmid 1156
                        p = (unsigned char *) ptr;
2766 cbradney 1157
                        r = p[0];
1158
                        b = p[2];
1159
                        p[2] = r;
1160
                        p[0] = b;
1161
                        ptr++;
2012 fschmid 1162
                }
1163
        }
1164
}
1165
 
2025 fschmid 1166
void ScImage::createLowRes(double scale)
2012 fschmid 1167
{
2025 fschmid 1168
        int w = qRound(width() / scale);
1169
        int h = qRound(height() / scale);
2012 fschmid 1170
        QImage tmp = smoothScale(w, h);
1171
        create(w, h, 32);
6020 fschmid 1172
        setAlphaBuffer(true);
1173
        tmp = tmp.convertDepth(32);
7175 fschmid 1174
        QRgb *s;
1175
        QRgb *d;
2012 fschmid 1176
        for( int yi=0; yi < tmp.height(); ++yi )
1177
        {
7175 fschmid 1178
                s = (QRgb*)(tmp.scanLine( yi ));
1179
                d = (QRgb*)(scanLine( yi ));
2012 fschmid 1180
                for(int xi=0; xi < tmp.width(); ++xi )
1181
                {
1182
                        (*d) = (*s);
1183
                        s++;
1184
                        d++;
1185
                }
1186
        }
1187
}
1188
 
2004 fschmid 1189
void ScImage::Convert2JPG(QString fn, int Quality, bool isCMYK, bool isGray)
1190
{
1191
        struct jpeg_compress_struct cinfo;
1192
        struct my_error_mgr         jerr;
1193
        FILE     *outfile;
1194
        JSAMPROW row_pointer[1];
1195
        row_pointer[0] = 0;
1196
        cinfo.err = jpeg_std_error (&jerr.pub);
1197
        jerr.pub.error_exit = my_error_exit;
1198
        outfile = NULL;
1199
        if (setjmp (jerr.setjmp_buffer))
1200
        {
1201
                jpeg_destroy_compress (&cinfo);
1202
                if (outfile)
1203
                        fclose (outfile);
1204
                return;
1205
        }
1206
        jpeg_create_compress (&cinfo);
2643 craig 1207
        if ((outfile = fopen (fn.local8Bit(), "wb")) == NULL)
2004 fschmid 1208
                return;
1209
        jpeg_stdio_dest (&cinfo, outfile);
1210
        cinfo.image_width  = width();
1211
        cinfo.image_height = height();
1212
        if (isCMYK)
1213
        {
1214
                cinfo.in_color_space = JCS_CMYK;
1215
                cinfo.input_components = 4;
1216
        }
1217
        else
1218
        {
1219
                if (isGray)
1220
                {
1221
                        cinfo.in_color_space = JCS_GRAYSCALE;
1222
                        cinfo.input_components = 1;
1223
                }
1224
                else
1225
                {
1226
                        cinfo.in_color_space = JCS_RGB;
1227
                        cinfo.input_components = 3;
1228
                }
1229
        }
1230
        jpeg_set_defaults (&cinfo);
1231
        int qual[] = { 95, 85, 75, 50, 25 };  // These are the JPEG Quality settings 100 means best, 0 .. don't discuss
1232
        jpeg_set_quality (&cinfo, qual[Quality], true);
2680 cbradney 1233
        jpeg_start_compress (&cinfo, true);
2004 fschmid 1234
        row_pointer[0] = new uchar[cinfo.image_width*cinfo.input_components];
1235
        int w = cinfo.image_width;
1236
        while (cinfo.next_scanline < cinfo.image_height)
1237
        {
1238
                uchar *row = row_pointer[0];
1239
                if (isCMYK)
1240
                {
1241
                        QRgb* rgba = (QRgb*)scanLine(cinfo.next_scanline);
1242
                        for (int i=0; i<w; ++i)
1243
                        {
3963 fschmid 1244
                                *row++ = 255-qRed(*rgba);
1245
                                *row++ = 255-qGreen(*rgba);
1246
                                *row++ = 255-qBlue(*rgba);
1247
                                *row++ = 255-qAlpha(*rgba);
2004 fschmid 1248
                                ++rgba;
1249
                        }
1250
                }
1251
                else
1252
                {
1253
                        if (isGray)
1254
                        {
1255
                                QRgb* rgba = (QRgb*)scanLine(cinfo.next_scanline);
1256
                                for (int i=0; i<w; ++i)
1257
                                {
1258
                                        *row++ = qRed(*rgba);
1259
                                        ++rgba;
1260
                                }
1261
                        }
1262
                        else
1263
                        {
1264
                                QRgb* rgb = (QRgb*)scanLine(cinfo.next_scanline);
1265
                                for (int i=0; i<w; i++)
1266
                                {
1267
                                        *row++ = qRed(*rgb);
1268
                                        *row++ = qGreen(*rgb);
1269
                                        *row++ = qBlue(*rgb);
1270
                                        ++rgb;
1271
                                }
1272
                        }
1273
                }
1274
                jpeg_write_scanlines (&cinfo, row_pointer, 1);
1275
        }
1276
        jpeg_finish_compress (&cinfo);
1277
        fclose (outfile);
1278
        jpeg_destroy_compress (&cinfo);
1279
        delete [] row_pointer[0];
1280
}
1281
 
5234 fschmid 1282
QByteArray ScImage::ImageToArray()
2004 fschmid 1283
{
2884 fschmid 1284
        int i = 0;
2004 fschmid 1285
        int h = height();
1286
        int w = width();
2884 fschmid 1287
        unsigned char u;
7175 fschmid 1288
        QRgb *s;
1289
        QRgb r;
5234 fschmid 1290
        QByteArray imgArray(3 * h * w);
2004 fschmid 1291
        for( int yi=0; yi < h; ++yi )
1292
        {
7175 fschmid 1293
                s = (QRgb*)(scanLine( yi ));
2004 fschmid 1294
                for( int xi=0; xi < w; ++xi )
1295
                {
7175 fschmid 1296
                        r = *s++;
2884 fschmid 1297
                        u=qRed(r);
5234 fschmid 1298
                        imgArray[i++] = u;
2004 fschmid 1299
                        u=qGreen(r);
5234 fschmid 1300
                        imgArray[i++] = u;
2004 fschmid 1301
                        u=qBlue(r);
5234 fschmid 1302
                        imgArray[i++] = u;
2004 fschmid 1303
                }
1304
        }
5234 fschmid 1305
        return imgArray;
2004 fschmid 1306
}
1307
 
5234 fschmid 1308
QByteArray ScImage::ImageToGray()
2004 fschmid 1309
{
2884 fschmid 1310
        int i = 0;
2004 fschmid 1311
        int h = height();
1312
        int w = width();
7175 fschmid 1313
        QRgb *s;
1314
        QRgb r;
5234 fschmid 1315
        QByteArray imgArray(h * w);
7175 fschmid 1316
        int k;
2004 fschmid 1317
        for( int yi=0; yi < h; ++yi )
1318
        {
7175 fschmid 1319
                s = (QRgb*)(scanLine( yi ));
2004 fschmid 1320
                for( int xi=0; xi < w; ++xi )
1321
                {
7175 fschmid 1322
                        r = *s;
7355 fschmid 1323
                        k = QMIN(qRound(0.3 * qRed(r) + 0.59 * qGreen(r) + 0.11 * qBlue(r)), 255);
1324
                        *s = qRgba(k, 0, 0, 0);
5234 fschmid 1325
                        imgArray[i++] = k;
2004 fschmid 1326
                        s++;
1327
                }
1328
        }
5234 fschmid 1329
        return imgArray;
2004 fschmid 1330
}
1331
 
5234 fschmid 1332
QByteArray ScImage::ImageToCMYK_PDF(bool pre)
2004 fschmid 1333
{
2884 fschmid 1334
        int i = 0;
2004 fschmid 1335
        int h = height();
1336
        int w = width();
7175 fschmid 1337
        QRgb *s;
1338
        QRgb r;
1339
        int c, m, y, k;
5234 fschmid 1340
        QByteArray imgArray( 4 * h * w );
2004 fschmid 1341
        if (pre)
1342
        {
1343
                for( int yi=0; yi < h; ++yi )
1344
                {
7175 fschmid 1345
                        s = (QRgb*)(scanLine( yi ));
2004 fschmid 1346
                        for( int xi=0; xi < w; ++xi )
1347
                        {
7175 fschmid 1348
                                r = *s;
1349
                                imgArray[i++] = static_cast<unsigned char> (qRed(r));
1350
                                imgArray[i++] = static_cast<unsigned char> (qGreen(r));
1351
                                imgArray[i++] = static_cast<unsigned char> (qBlue(r));
1352
                                imgArray[i++] = static_cast<unsigned char> (qAlpha(r));
2004 fschmid 1353
                                s++;
1354
                        }
1355
                }
1356
        }
1357
        else
1358
        {
1359
                for( int yi=0; yi < h; ++yi )
1360
                {
7175 fschmid 1361
                        s = (QRgb*)(scanLine( yi ));
2004 fschmid 1362
                        for( int xi=0; xi < w; ++xi )
1363
                        {
7175 fschmid 1364
                                r = *s;
1365
                                c = 255 - qRed(r);
1366
                                m = 255 - qGreen(r);
1367
                                y = 255 - qBlue(r);
1368
                                k = QMIN(QMIN(c, m), y);
5234 fschmid 1369
                                imgArray[i++] = static_cast<unsigned char> (c - k);
1370
                                imgArray[i++] = static_cast<unsigned char> (m - k);
1371
                                imgArray[i++] = static_cast<unsigned char> (y - k);
1372
                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1373
                                s++;
1374
                        }
1375
                }
1376
        }
5234 fschmid 1377
        return imgArray;
2004 fschmid 1378
}
1379
 
5234 fschmid 1380
QByteArray ScImage::ImageToCMYK_PS(int pl, bool pre)
2004 fschmid 1381
{
2884 fschmid 1382
        int i = 0;
2004 fschmid 1383
        int h = height();
1384
        int w = width();
5234 fschmid 1385
        QByteArray imgArray;
7175 fschmid 1386
        QRgb *s;
1387
        QRgb r;
1388
        int c, m, y, k;
2884 fschmid 1389
        if(pl == -1)
5234 fschmid 1390
                imgArray.resize(4 * h * w);
2884 fschmid 1391
        else
5234 fschmid 1392
                imgArray.resize(h * w);
2004 fschmid 1393
        if (pre)
1394
        {
1395
                for( int yi=0; yi < h; ++yi )
1396
                {
7175 fschmid 1397
                        s = (QRgb*)(scanLine( yi ));
2004 fschmid 1398
                        for( int xi=0; xi < w; ++xi )
1399
                        {
7175 fschmid 1400
                                r = *s++;
1401
                                c = qRed(r);
1402
                                m = qGreen(r);
1403
                                y = qBlue(r);
1404
                                k = qAlpha(r);
2004 fschmid 1405
                                if (pl == -1)
1406
                                {
5234 fschmid 1407
                                        imgArray[i++] = static_cast<unsigned char> (c);
1408
                                        imgArray[i++] = static_cast<unsigned char> (m);
1409
                                        imgArray[i++] = static_cast<unsigned char> (y);
1410
                                        imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1411
                                }
1412
                                else
1413
                                {
1414
                                        if (pl == -2)
5234 fschmid 1415
                                                imgArray[i++] = static_cast<unsigned char> (QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k)));
2004 fschmid 1416
                                        if (pl == 1)
5234 fschmid 1417
                                                imgArray[i++] = static_cast<unsigned char> (c);
2004 fschmid 1418
                                        if (pl == 2)
5234 fschmid 1419
                                                imgArray[i++] = static_cast<unsigned char> (m);
2004 fschmid 1420
                                        if (pl == 3)
5234 fschmid 1421
                                                imgArray[i++] = static_cast<unsigned char> (y);
2004 fschmid 1422
                                        if (pl == 0)
5234 fschmid 1423
                                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1424
                                }
1425
                        }
1426
                }
1427
        }
1428
        else
1429
        {
1430
                for( int yi=0; yi < h; ++yi )
1431
                {
7175 fschmid 1432
                        s = (QRgb*)(scanLine( yi ));
2004 fschmid 1433
                        for( int xi=0; xi < w; ++xi )
1434
                        {
7175 fschmid 1435
                                r = *s++;
1436
                                c = 255 - qRed(r);
1437
                                m = 255 - qGreen(r);
1438
                                y = 255 - qBlue(r);
1439
                                k = QMIN(QMIN(c, m), y);
2004 fschmid 1440
                                if (pl == -1)
1441
                                {
5234 fschmid 1442
                                        imgArray[i++] = static_cast<unsigned char> (c - k);
1443
                                        imgArray[i++] = static_cast<unsigned char> (m - k);
1444
                                        imgArray[i++] = static_cast<unsigned char> (y - k);
1445
                                        imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1446
                                }
1447
                                else
1448
                                {
1449
                                        if (pl == -2)
5234 fschmid 1450
                                                imgArray[i++] = static_cast<unsigned char> (QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k)));
2004 fschmid 1451
                                        if (pl == 1)
5234 fschmid 1452
                                                imgArray[i++] = static_cast<unsigned char> (c - k);
2004 fschmid 1453
                                        if (pl == 2)
5234 fschmid 1454
                                                imgArray[i++] = static_cast<unsigned char> (m - k);
2004 fschmid 1455
                                        if (pl == 3)
5234 fschmid 1456
                                                imgArray[i++] = static_cast<unsigned char> (y - k);
2004 fschmid 1457
                                        if (pl == 0)
5234 fschmid 1458
                                                imgArray[i++] = static_cast<unsigned char> (k);
2004 fschmid 1459
                                }
1460
                        }
1461
                }
1462
        }
5234 fschmid 1463
        return imgArray;
2004 fschmid 1464
}
1465
 
1466
void ScImage::scaleImage(int nwidth, int nheight)
1467
{
1468
        QImage dst;
1469
        dst.create(nwidth, nheight,32);
1470
        QRgb* xelrow = 0;
1471
        QRgb* tempxelrow = 0;
1472
        register QRgb* xP;
1473
        register QRgb* nxP;
1474
        int rows, cols, rowsread, newrows, newcols;
1475
        register int row, col, needtoreadrow;
1476
        const uchar maxval = 255;
1477
        double xscale, yscale;
1478
        long sxscale, syscale;
1479
        register long fracrowtofill, fracrowleft;
1480
        long* as;
1481
        long* rs;
1482
        long* gs;
1483
        long* bs;
1484
        int rowswritten = 0;
1485
        cols = width();
1486
        rows = height();
1487
        newcols = dst.width();
1488
        newrows = dst.height();
1489
        long SCALE;
1490
        long HALFSCALE;
1491
        if (cols > 4096)
1492
        {
1493
                SCALE = 4096;
1494
                HALFSCALE = 2048;
1495
        }
1496
        else
1497
        {
1498
                int fac = 4096;
1499
                while (cols * fac > 4096)
1500
                {
1501
                        fac /= 2;
1502
                }
1503
                SCALE = fac * cols;
1504
                HALFSCALE = fac * cols / 2;
1505
        }
1506
        xscale = (double) newcols / (double) cols;
1507
        yscale = (double) newrows / (double) rows;
1508
        sxscale = (long)(xscale * SCALE);
1509
        syscale = (long)(yscale * SCALE);
1510
        if ( newrows != rows )  /* shortcut Y scaling if possible */
1511
                tempxelrow = new QRgb[cols];
1512
        as = new long[cols];
1513
        rs = new long[cols];
1514
        gs = new long[cols];
1515
        bs = new long[cols];
1516
        rowsread = 0;
1517
        fracrowleft = syscale;
1518
        needtoreadrow = 1;
1519
        for ( col = 0; col < cols; ++col )
1520
                rs[col] = gs[col] =  as[col] = bs[col] = HALFSCALE;
1521
        fracrowtofill = SCALE;
1522
        for ( row = 0; row < newrows; ++row )
1523
        {
1524
                if ( newrows == rows )
1525
                        tempxelrow = xelrow = (QRgb*)scanLine(rowsread++);
1526
                else
1527
                {
1528
                        while ( fracrowleft < fracrowtofill )
1529
                        {
1530
                                if ( needtoreadrow && rowsread < rows )
1531
                                        xelrow = (QRgb*)scanLine(rowsread++);
1532
                                for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
1533
                                {
1534
                                        as[col] += fracrowleft * qAlpha( *xP );
1535
                                        rs[col] += fracrowleft * qRed( *xP );
1536
                                        gs[col] += fracrowleft * qGreen( *xP );
1537
                                        bs[col] += fracrowleft * qBlue( *xP );
1538
                                }
1539
                                fracrowtofill -= fracrowleft;
1540
                                fracrowleft = syscale;
1541
                                needtoreadrow = 1;
1542
                        }
1543
                        if ( needtoreadrow && rowsread < rows )
1544
                        {
1545
                                xelrow = (QRgb*)scanLine(rowsread++);
1546
                                needtoreadrow = 0;
1547
                        }
1548
                        register long a=0;
1549
                        for ( col = 0, xP = xelrow, nxP = tempxelrow; col < cols; ++col, ++xP, ++nxP )
1550
                        {
1551
                                register long r, g, b;
1552
                                a = as[col] + fracrowtofill * qAlpha( *xP );
1553
                                r = rs[col] + fracrowtofill * qRed( *xP );
1554
                                g = gs[col] + fracrowtofill * qGreen( *xP );
1555
                                b = bs[col] + fracrowtofill * qBlue( *xP );
1556
                                r /= SCALE;
1557
                                if ( r > maxval ) r = maxval;
1558
                                g /= SCALE;
1559
                                if ( g > maxval ) g = maxval;
1560
                                b /= SCALE;
1561
                                if ( b > maxval ) b = maxval;
1562
                                a /= SCALE;
1563
                                if ( a > maxval ) a = maxval;
1564
                                *nxP = qRgba( (int)r, (int)g, (int)b , (int)a);
1565
                                rs[col] = as[col] = gs[col] = bs[col] = HALFSCALE;
1566
                        }
1567
                        fracrowleft -= fracrowtofill;
1568
                        if ( fracrowleft == 0 )
1569
                        {
1570
                                fracrowleft = syscale;
1571
                                needtoreadrow = 1;
1572
                        }
1573
                        fracrowtofill = SCALE;
1574
                }
1575
                if ( newcols == cols )
1576
                        memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
1577
                else
1578
                {
1579
                        register long a, r, g, b;
1580
                        register long fraccoltofill, fraccolleft = 0;
1581
                        register int needcol;
1582
                        nxP = (QRgb*)dst.scanLine(rowswritten++);
1583
                        fraccoltofill = SCALE;
1584
                        a = r = g = b = HALFSCALE;
1585
                        needcol = 0;
1586
                        for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP )
1587
                        {
1588
                                fraccolleft = sxscale;
1589
                                while ( fraccolleft >= fraccoltofill )
1590
                                {
1591
                                        if ( needcol )
1592
                                        {
1593
                                                ++nxP;
1594
                                                a = r = g = b = HALFSCALE;
1595
                                        }
1596
                                        a += fraccoltofill * qAlpha( *xP );
1597
                                        r += fraccoltofill * qRed( *xP );
1598
                                        g += fraccoltofill * qGreen( *xP );
1599
                                        b += fraccoltofill * qBlue( *xP );
1600
                                        r /= SCALE;
1601
                                        if ( r > maxval ) r = maxval;
1602
                                        g /= SCALE;
1603
                                        if ( g > maxval ) g = maxval;
1604
                                        b /= SCALE;
1605
                                        if ( b > maxval ) b = maxval;
1606
                                        a /= SCALE;
1607
                                        if ( a > maxval ) a = maxval;
1608
                                        *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
1609
                                        fraccolleft -= fraccoltofill;
1610
                                        fraccoltofill = SCALE;
1611
                                        needcol = 1;
1612
                                }
1613
                                if ( fraccolleft > 0 )
1614
                                {
1615
                                        if ( needcol )
1616
                                        {
1617
                                                ++nxP;
1618
                                                a = r = g = b = HALFSCALE;
1619
                                                needcol = 0;
1620
                                        }
1621
                                        a += fraccolleft * qAlpha( *xP );
1622
                                        r += fraccolleft * qRed( *xP );
1623
                                        g += fraccolleft * qGreen( *xP );
1624
                                        b += fraccolleft * qBlue( *xP );
1625
                                        fraccoltofill -= fraccolleft;
1626
                                }
1627
                        }
1628
                        if ( fraccoltofill > 0 )
1629
                        {
1630
                                --xP;
1631
                                a += fraccolleft * qAlpha( *xP );
1632
                                r += fraccoltofill * qRed( *xP );
1633
                                g += fraccoltofill * qGreen( *xP );
1634
                                b += fraccoltofill * qBlue( *xP );
1635
                        }
1636
                        if ( ! needcol )
1637
                        {
1638
                                r /= SCALE;
1639
                                if ( r > maxval ) r = maxval;
1640
                                g /= SCALE;
1641
                                if ( g > maxval ) g = maxval;
1642
                                b /= SCALE;
1643
                                if ( b > maxval ) b = maxval;
1644
                                a /= SCALE;
1645
                                if ( a > maxval ) a = maxval;
1646
                                *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
1647
                        }
1648
                }
1649
        }
1650
        if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
1651
                delete [] tempxelrow;
1652
        if ( as )                               // Avoid purify complaint
1653
                delete [] as;
1654
        if ( rs )                               // Robust, rs might be 0 one day
1655
                delete [] rs;
1656
        if ( gs )                               // Robust, gs might be 0 one day
1657
                delete [] gs;
1658
        if ( bs )                               // Robust, bs might be 0 one day
1659
                delete [] bs;
1660
        create(nwidth, nheight,32);
1661
        for( int yi=0; yi < dst.height(); ++yi )
1662
        {
1663
                QRgb *s = (QRgb*)(dst.scanLine( yi ));
1664
                QRgb *d = (QRgb*)(scanLine( yi ));
1665
                for(int xi=0; xi < dst.width(); ++xi )
1666
                {
1667
                        (*d) = (*s);
1668
                        s++;
1669
                        d++;
1670
                }
1671
        }
1672
        return;
1673
}
1674
 
8403 fschmid 1675
QByteArray ScImage::getAlpha(QString fn, bool PDF, bool pdf14, int gsRes, int scaleXSize, int scaleYSize)
2004 fschmid 1676
{
5234 fschmid 1677
        QByteArray retArray;
5937 jghali 1678
        ScImgDataLoader* pDataLoader = NULL;
2004 fschmid 1679
        imgInfo.valid = false;
1680
        imgInfo.clipPath = "";
1681
        imgInfo.PDSpathData.clear();
1682
        imgInfo.layerInfo.clear();
1683
        QFileInfo fi = QFileInfo(fn);
1684
        if (!fi.exists())
5234 fschmid 1685
                return retArray;
2995 fschmid 1686
        QString tmp, BBox, tmp2;
2004 fschmid 1687
        QString ext = fi.extension(false).lower();
2995 fschmid 1688
        if ((ext == "jpg") || (ext == "jpeg"))
5234 fschmid 1689
                return retArray;
2995 fschmid 1690
        if (ext == "pdf")
5937 jghali 1691
                pDataLoader = new ScImgDataLoader_PDF();
7420 fschmid 1692
        else if ((ext == "eps") || (ext == "epsi") || (ext == "ps"))
5937 jghali 1693
                pDataLoader = new ScImgDataLoader_PS();
1694
        else if ((ext == "tif") || (ext == "tiff"))
6873 fschmid 1695
        {
5937 jghali 1696
                pDataLoader = new ScImgDataLoader_TIFF();
6873 fschmid 1697
                if      (pDataLoader)
1698
                        pDataLoader->setRequest(imgInfo.isRequest, imgInfo.RequestProps);
1699
        }
5937 jghali 1700
        else if (ext == "psd")
6873 fschmid 1701
        {
5937 jghali 1702
                pDataLoader = new ScImgDataLoader_PSD();
6873 fschmid 1703
                if      (pDataLoader)
1704
                        pDataLoader->setRequest(imgInfo.isRequest, imgInfo.RequestProps);
1705
        }
5937 jghali 1706
        else
1707
                pDataLoader = new ScImgDataLoader_QT();
1708
 
1709
        if      (pDataLoader)
2995 fschmid 1710
        {
5937 jghali 1711
                pDataLoader->preloadAlphaChannel(fn, gsRes);
6835 fschmid 1712
                QImage rImage;
6854 fschmid 1713
                if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
6835 fschmid 1714
                {
8444 fschmid 1715
                        if (pDataLoader->imageInfoRecord().valid)
1716
                        {
1717
                                if ((pDataLoader->r_image.channels() == 5) || (pDataLoader->imageInfoRecord().colorspace == 1))
1718
                                        rImage = pDataLoader->r_image.convertToQImage(true);
1719
                                else
1720
                                        rImage = pDataLoader->r_image.convertToQImage(false);
1721
                        }
6835 fschmid 1722
                        else
8444 fschmid 1723
                        {
1724
                                delete pDataLoader;
1725
                                return retArray;
1726
                        }
6835 fschmid 1727
                }
1728
                else
1729
                        rImage = pDataLoader->image();
5937 jghali 1730
                if (rImage.isNull())
2995 fschmid 1731
                {
5937 jghali 1732
                        delete pDataLoader;
1733
                        return retArray;
2995 fschmid 1734
                }
8403 fschmid 1735
                if ((scaleXSize != 0) && (scaleYSize != 0))
1736
                        rImage = rImage.smoothScale(scaleXSize, scaleYSize);
5937 jghali 1737
                int i = 0;
1738
                unsigned char u;
1739
                int hm = rImage.height();
1740
                int wm = rImage.width();
1741
                int w2;
7175 fschmid 1742
                QRgb *s;
1743
                QRgb r;
5937 jghali 1744
                if (pdf14)
2995 fschmid 1745
                {
5937 jghali 1746
                        retArray.resize(hm * wm);
1747
                        for( int yi=0; yi < hm; ++yi )
2995 fschmid 1748
                        {
7175 fschmid 1749
                                s = (QRgb*)(rImage.scanLine( yi ));
5937 jghali 1750
                                for( int xi=0; xi < wm; ++xi )
2995 fschmid 1751
                                {
7175 fschmid 1752
                                        r = *s++;
5937 jghali 1753
                                        u=qAlpha(r);
1754
                                        retArray[i++] = u;
2995 fschmid 1755
                                }
1756
                        }
1757
                }
5937 jghali 1758
                else
2004 fschmid 1759
                {
5937 jghali 1760
                        QImage iMask = rImage.createAlphaMask();
1761
                        hm = iMask.height();
1762
                        wm = iMask.width();
1763
                        w2 = wm / 8;
1764
                        if ((wm % 8) != 0)
1765
                                w2++;
1766
                        retArray.resize(hm * w2);
7175 fschmid 1767
                        uchar * s;
5937 jghali 1768
                        for( int yi=0; yi < hm; ++yi )
2004 fschmid 1769
                        {
7175 fschmid 1770
                                s = iMask.scanLine( yi );
5937 jghali 1771
                                for( int xi=0; xi < w2; ++xi )
2004 fschmid 1772
                                {
5937 jghali 1773
                                        u = *(s+xi);
1774
                                        if(PDF) u = ~u;
1775
                                        retArray[i++] = u;
2004 fschmid 1776
                                }
1777
                        }
1778
                }
5937 jghali 1779
                delete pDataLoader;
2004 fschmid 1780
        }
5234 fschmid 1781
        return retArray;
2004 fschmid 1782
}
1783
 
5234 fschmid 1784
void ScImage::getEmbeddedProfile(const QString & fn, QByteArray *profile, int *components)
1785
{
1786
        Q_ASSERT(profile);
1787
        Q_ASSERT(components);
5937 jghali 1788
        ScImgDataLoader* pDataLoader = NULL;
1789
        cmsHPROFILE prof = 0;
1790
 
1791
        profile->resize(0);
1792
        *components = 0;
5234 fschmid 1793
        QFileInfo fi = QFileInfo(fn);
1794
        if (!fi.exists())
1795
                return;
1796
        QString ext = fi.extension(false).lower();
5937 jghali 1797
 
5234 fschmid 1798
        if (ext == "psd")
5937 jghali 1799
                pDataLoader = new ScImgDataLoader_PSD();
7420 fschmid 1800
        else if ((ext == "eps") || (ext == "epsi"))
6744 fschmid 1801
                pDataLoader = new ScImgDataLoader_PS();
5234 fschmid 1802
        else if ((ext == "tif") || (ext == "tiff"))
5937 jghali 1803
                pDataLoader = new ScImgDataLoader_TIFF();
5234 fschmid 1804
        else if ((ext == "jpg") || (ext == "jpeg"))
5937 jghali 1805
                pDataLoader = new ScImgDataLoader_JPEG();
1806
 
1807
        if      (pDataLoader)
5234 fschmid 1808
        {
5937 jghali 1809
                pDataLoader->loadEmbeddedProfile(fn);
1810
                QByteArray embeddedProfile = pDataLoader->embeddedProfile();
1811
                if      (embeddedProfile.size())
5234 fschmid 1812
                {
5937 jghali 1813
                        prof = cmsOpenProfileFromMem(embeddedProfile.data(), embeddedProfile.size());
1814
                        if (prof)
5234 fschmid 1815
                        {
5937 jghali 1816
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigRgbData)
5234 fschmid 1817
                                        *components = 3;
5937 jghali 1818
                                if (static_cast<int>(cmsGetColorSpace(prof)) == icSigCmykData)
5234 fschmid 1819
                                        *components = 4;
5937 jghali 1820
                                *profile = embeddedProfile;
5234 fschmid 1821
                        }
5937 jghali 1822
                        cmsCloseProfile(prof);
5234 fschmid 1823
                }
5937 jghali 1824
                delete pDataLoader;
5234 fschmid 1825
        }
1826
}
1827
 
5781 cbradney 1828
bool ScImage::LoadPicture(const QString & fn, const CMSettings& cmSettings,
5977 jghali 1829
                                                  bool useEmbedded, bool useProf, RequestType requestType,
1830
                                                  int gsRes, bool *realCMYK, bool showMsg)
2004 fschmid 1831
{
3685 fschmid 1832
        // requestType - 0: CMYK, 1: RGB, 2: RGB Proof 3 : RawData, 4: Thumbnail
2004 fschmid 1833
        // gsRes - is the resolution that ghostscript will render at
1834
        bool isCMYK = false;
1835
        bool ret = false;
7299 fschmid 1836
        bool inputProfisEmbedded = false;
1837
        bool stdProof = false;
2004 fschmid 1838
        if (realCMYK != 0)
1839
                *realCMYK = false;
1840
        bool bilevel = false;
6854 fschmid 1841
//      short resolutionunit = 0;
5345 mrdocs 1842
        RequestType reqType = requestType;
2004 fschmid 1843
        cmsHTRANSFORM xform = 0;
1844
        cmsHPROFILE inputProf = 0;
1845
        int cmsFlags = 0;
8463 jghali 1846
        int cmsProofFlags = 0;
5937 jghali 1847
        auto_ptr<ScImgDataLoader> pDataLoader;
2004 fschmid 1848
        QFileInfo fi = QFileInfo(fn);
1849
        if (!fi.exists())
1850
                return ret;
1851
        QString ext = fi.extension(false).lower();
1852
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
1853
        QChar tc;
6854 fschmid 1854
//      bool found = false;
5937 jghali 1855
 
6808 fschmid 1856
        if (ext.isEmpty())
1857
                ext = getImageType(fn);
1858
 
2004 fschmid 1859
        if (ext == "pdf")
5937 jghali 1860
                pDataLoader.reset( new ScImgDataLoader_PDF() );
7420 fschmid 1861
        else if ((ext == "eps") || (ext == "epsi") || (ext == "ps"))
5937 jghali 1862
                pDataLoader.reset( new ScImgDataLoader_PS() );
2004 fschmid 1863
        else if ((ext == "tif") || (ext == "tiff"))
6589 fschmid 1864
        {
5937 jghali 1865
                pDataLoader.reset( new ScImgDataLoader_TIFF() );
6589 fschmid 1866
                pDataLoader->setRequest(imgInfo.isRequest, imgInfo.RequestProps);
1867
        }
2004 fschmid 1868
        else if (ext == "psd")
6138 fschmid 1869
        {
5937 jghali 1870
                pDataLoader.reset( new ScImgDataLoader_PSD() );
6138 fschmid 1871
                pDataLoader->setRequest(imgInfo.isRequest, imgInfo.RequestProps);
1872
        }
2004 fschmid 1873
        else if ((ext == "jpg") || (ext == "jpeg"))
5937 jghali 1874
                pDataLoader.reset( new ScImgDataLoader_JPEG() );
6412 fschmid 1875
        else if (ext == "pat")
1876
                pDataLoader.reset( new ScImgDataLoader_GIMP() );
5937 jghali 1877
        else
1878
                pDataLoader.reset( new ScImgDataLoader_QT() );
1879
 
1880
        if      (pDataLoader->loadPicture(fn, gsRes, (requestType == Thumbnail)))
2004 fschmid 1881
        {
5937 jghali 1882
                *this = pDataLoader->image();
1883
                imgInfo = pDataLoader->imageInfoRecord();
1884
                if (requestType == Thumbnail)
6716 fschmid 1885
                        reqType = RGBData;
5937 jghali 1886
                if (!cmSettings.useColorManagement() || !useProf)
2004 fschmid 1887
                {
3005 fschmid 1888
                        imgInfo.isEmbedded = false;
2004 fschmid 1889
                        imgInfo.profileName = "";
3005 fschmid 1890
                }
5937 jghali 1891
                if (imgInfo.colorspace == 1)
2004 fschmid 1892
                {
2742 fschmid 1893
                        isCMYK = true;
5937 jghali 1894
                        if(realCMYK)
1895
                                *realCMYK = true;
2742 fschmid 1896
                }
5941 jghali 1897
                else if (imgInfo.colorspace == 2)
1898
                        bilevel = true;
5937 jghali 1899
                pDataLoader->image() = QImage();
2004 fschmid 1900
        }
1901
        else
5977 jghali 1902
        {
1903
                if      (ScCore->usingGUI() && pDataLoader->issuedErrorMsg() && showMsg)
1904
                {
1905
                        QMessageBox::critical(ScCore->primaryMainWindow(), CommonStrings::trWarning, pDataLoader->getMessage(), 1, 0, 0);
1906
                }
1907
                else if (pDataLoader->issuedErrorMsg())
1908
                {
1909
                        QString msg = pDataLoader->getMessage();
1910
                        qWarning( msg.local8Bit().data() );
1911
                }
5937 jghali 1912
                return false;
5977 jghali 1913
        }
5937 jghali 1914
 
6850 fschmid 1915
        if (!((ext == "psd") || (ext == "tif") || (ext == "tiff")))
6835 fschmid 1916
        {
1917
                if (isNull())
1918
                        return  ret;
1919
        }
5937 jghali 1920
 
1921
        QByteArray embeddedProfile = pDataLoader->embeddedProfile();
5788 jghali 1922
        if (cmSettings.useColorManagement() && useProf)
2004 fschmid 1923
        {
5937 jghali 1924
                if (embeddedProfile.size() > 0 )
1925
                {
1926
                        inputProf = cmsOpenProfileFromMem(embeddedProfile.data(), embeddedProfile.size());
7299 fschmid 1927
                        inputProfisEmbedded = true;
5937 jghali 1928
                }
2004 fschmid 1929
                else
1930
                {
3745 craig 1931
                        QCString profilePath;
5781 cbradney 1932
                        //CB If this is null, customfiledialog/picsearch/ScPreview might be sending it
1933
                        Q_ASSERT(cmSettings.doc()!=0);
2004 fschmid 1934
                        if (isCMYK)
2995 fschmid 1935
                        {
7299 fschmid 1936
                                if (ScCore->InputProfilesCMYK.contains(cmSettings.profileName()) && (cmSettings.profileName() != cmSettings.doc()->CMSSettings.DefaultImageCMYKProfile))
1937
                                {
5781 cbradney 1938
                                        imgInfo.profileName = cmSettings.profileName();
7299 fschmid 1939
                                        inputProfisEmbedded = true;
1940
                                        profilePath = ScCore->InputProfilesCMYK[imgInfo.profileName].local8Bit();
1941
                                        inputProf = cmsOpenProfileFromFile(profilePath.data(), "r");
1942
                                }
3005 fschmid 1943
                                else
7299 fschmid 1944
                                {
1945
                                        inputProf = cmSettings.doc()->DocInputImageCMYKProf;
5781 cbradney 1946
                                        imgInfo.profileName = cmSettings.doc()->CMSSettings.DefaultImageCMYKProfile;
7299 fschmid 1947
                                        inputProfisEmbedded = false;
1948
                                }
2995 fschmid 1949
                        }
2004 fschmid 1950
                        else
2995 fschmid 1951
                        {
7299 fschmid 1952
                                if (ScCore->InputProfiles.contains(cmSettings.profileName()) && (cmSettings.profileName() != cmSettings.doc()->CMSSettings.DefaultImageRGBProfile))
1953
                                {
5781 cbradney 1954
                                        imgInfo.profileName = cmSettings.profileName();
7299 fschmid 1955
                                        profilePath = ScCore->InputProfiles[imgInfo.profileName].local8Bit();
1956
                                        inputProfisEmbedded = true;
1957
                                        inputProf = cmsOpenProfileFromFile(profilePath.data(), "r");
1958
                                }
3005 fschmid 1959
                                else
7299 fschmid 1960
                                {
1961
                                        inputProf = cmSettings.doc()->DocInputImageRGBProf;
5781 cbradney 1962
                                        imgInfo.profileName = cmSettings.doc()->CMSSettings.DefaultImageRGBProfile;
7299 fschmid 1963
                                        inputProfisEmbedded = false;
1964
                                }
2995 fschmid 1965
                        }
2004 fschmid 1966
                }
1967
        }
5788 jghali 1968
        if (cmSettings.useColorManagement() && useProf && inputProf)
2004 fschmid 1969
        {
8451 jghali 1970
                bool  isPsdTiff = ((ext == "psd") || (ext == "tif") || (ext == "tiff"));
1971
                DWORD SC_TYPE_YMCK_8 = (COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1));
1972
                DWORD inputProfFormat = TYPE_BGRA_8;
1973
                DWORD outputProfFormat = SC_TYPE_YMCK_8;
5555 mrdocs 1974
                int inputProfColorSpace = static_cast<int>(cmsGetColorSpace(inputProf));
1975
                if ( inputProfColorSpace == icSigRgbData )
8451 jghali 1976
                        inputProfFormat = isPsdTiff ? TYPE_RGBA_8 : TYPE_BGRA_8; // Later make tiff and psd loader use TYPE_BGRA_8
1977
                else if (( inputProfColorSpace == icSigCmykData ) && isPsdTiff)
6850 fschmid 1978
                {
1979
                        if (pDataLoader->r_image.channels() == 5)
6896 fschmid 1980
                                inputProfFormat = (COLORSPACE_SH(PT_CMYK)|EXTRA_SH(1)|CHANNELS_SH(4)|BYTES_SH(1));
6850 fschmid 1981
                        else
1982
                                inputProfFormat = TYPE_CMYK_8;
1983
                }
5555 mrdocs 1984
                else if ( inputProfColorSpace == icSigCmykData )
8451 jghali 1985
                        inputProfFormat = SC_TYPE_YMCK_8;
5555 mrdocs 1986
                else if ( inputProfColorSpace == icSigGrayData )
1987
                        inputProfFormat = TYPE_GRAY_8;
6070 jghali 1988
                int outputProfColorSpace = static_cast<int>(cmsGetColorSpace(cmSettings.printerProfile()));
1989
                if ( outputProfColorSpace == icSigRgbData )
8451 jghali 1990
                        outputProfFormat = TYPE_BGRA_8;
6070 jghali 1991
                else if ( outputProfColorSpace == icSigCmykData )
8451 jghali 1992
                        outputProfFormat = SC_TYPE_YMCK_8;
5788 jghali 1993
                if (cmSettings.doSoftProofing())
2004 fschmid 1994
                {
8463 jghali 1995
                        cmsProofFlags |= cmsFLAGS_SOFTPROOFING;
5788 jghali 1996
                        if (cmSettings.doGamutCheck())
7299 fschmid 1997
                        {
8463 jghali 1998
                                cmsProofFlags |= cmsFLAGS_GAMUTCHECK;
7299 fschmid 1999
                        }
2004 fschmid 2000
                }
5788 jghali 2001
                if (cmSettings.useBlackPoint())
2004 fschmid 2002
                        cmsFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
3685 fschmid 2003
                switch (reqType)
2004 fschmid 2004
                {
5345 mrdocs 2005
                case CMYKData: // CMYK
6671 fschmid 2006
//                      if ((!isCMYK && (outputProfColorSpace == icSigCmykData)) || (isCMYK && (outputProfColorSpace == icSigRgbData)) )
8463 jghali 2007
                                xform = scCmsCreateTransform(inputProf, inputProfFormat, cmSettings.printerProfile(), outputProfFormat, cmSettings.imageRenderingIntent(), cmsFlags);
6070 jghali 2008
                        if (outputProfColorSpace != icSigCmykData )
5846 jghali 2009
                                *realCMYK = isCMYK = false;
2004 fschmid 2010
                        break;
5992 fschmid 2011
                case Thumbnail:
5345 mrdocs 2012
                case RGBData: // RGB
2004 fschmid 2013
                        if (isCMYK)
8463 jghali 2014
                                xform = scCmsCreateTransform(inputProf, inputProfFormat, cmSettings.monitorProfile(), TYPE_BGRA_8, cmSettings.intent(), cmsFlags);
6848 fschmid 2015
                        else
2016
                        {
6850 fschmid 2017
                                if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
6848 fschmid 2018
                                {
2019
                                        *this = pDataLoader->r_image.convertToQImage(false);
2020
                                        imgInfo = pDataLoader->imageInfoRecord();
2021
                                }
2022
                        }
2004 fschmid 2023
                        break;
5345 mrdocs 2024
                case RGBProof: // RGB Proof
2004 fschmid 2025
                        {
5788 jghali 2026
                                if (cmSettings.doSoftProofing())
6070 jghali 2027
                                {
7299 fschmid 2028
                                        if ((imgInfo.profileName == cmSettings.doc()->CMSSettings.DefaultImageRGBProfile) || (imgInfo.profileName == cmSettings.doc()->CMSSettings.DefaultImageCMYKProfile))
2029
                                        {
2030
                                                if (isCMYK)
2031
                                                        xform = cmSettings.doc()->stdProofImgCMYK;
2032
                                                else
2033
                                                        xform = cmSettings.doc()->stdProofImg;
2034
                                                cmsChangeBuffersFormat(xform, inputProfFormat, TYPE_BGRA_8);
2035
                                                stdProof = true;
2036
                                        }
2037
                                        else
2038
                                                xform = scCmsCreateProofingTransform(inputProf, inputProfFormat,
6070 jghali 2039
                                                             cmSettings.monitorProfile(), TYPE_BGRA_8, cmSettings.printerProfile(),
8463 jghali 2040
                                                             cmSettings.intent(), INTENT_RELATIVE_COLORIMETRIC, cmsFlags | cmsProofFlags);
6070 jghali 2041
                                }
2095 fschmid 2042
                                else
6070 jghali 2043
                                        xform = scCmsCreateTransform(inputProf, inputProfFormat, cmSettings.monitorProfile(),
2044
                                                                                 TYPE_BGRA_8, cmSettings.intent(), cmsFlags);
2095 fschmid 2045
                        }
2004 fschmid 2046
                        break;
5345 mrdocs 2047
                case RawData: // no Conversion just raw Data
2004 fschmid 2048
                        xform = 0;
6850 fschmid 2049
                        if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
6848 fschmid 2050
                        {
2051
                                *this = pDataLoader->r_image.convertToQImage(true, true);
2052
                                imgInfo = pDataLoader->imageInfoRecord();
2053
                        }
2004 fschmid 2054
                        break;
2055
                }
2056
                if (xform)
2057
                {
6850 fschmid 2058
                        if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
6848 fschmid 2059
                        {
2060
                                create(pDataLoader->r_image.width(), pDataLoader->r_image.height(), 32);
2061
                                setAlphaBuffer( true );
2062
                                imgInfo = pDataLoader->imageInfoRecord();
2063
                        }
7978 fschmid 2064
                        LPBYTE ptr2 = NULL;
2004 fschmid 2065
                        for (int i = 0; i < height(); i++)
2066
                        {
2067
                                LPBYTE ptr = scanLine(i);
6850 fschmid 2068
                                if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
6848 fschmid 2069
                                        ptr2 = pDataLoader->r_image.scanLine(i);
5555 mrdocs 2070
                                if ( inputProfFormat == TYPE_GRAY_8 && (reqType != CMYKData) )
2071
                                {
2072
                                        unsigned char* ucs = ptr + 1;
2073
                                        unsigned char* uc = new unsigned char[width()];
2074
                                        for( int uci = 0; uci < width(); uci++ )
2075
                                        {
2076
                                                uc[uci] = *ucs;
2077
                                                ucs += 4;
2078
                                        }
2079
                                        cmsDoTransform(xform, uc, ptr, width());
2080
                                        delete[] uc;
2081
                                }
2082
                                else if ( inputProfFormat == TYPE_GRAY_8 && (reqType == CMYKData) )
2083
                                {
2084
                                        unsigned char  value;
2085
                                        unsigned char* ucs = ptr;
2086
                                        for( int uci = 0; uci < width(); uci++ )
2087
                                        {
2088
                                                value = 255 - *(ucs + 1);
2089
                                                ucs[0] = ucs[1] = ucs[2] = 0;
2090
                                                ucs[3] = value;
2091
                                                ucs += 4;
2092
                                        }
2093
                                }
2094
                                else
6848 fschmid 2095
                                {
6850 fschmid 2096
                                        if ((ext == "psd") || (ext == "tif") || (ext == "tiff"))
8430 fschmid 2097
                                        {
2098
                                                cmsDoTransform(xform, ptr2, ptr, width());
2099
                                        }
6848 fschmid 2100
                                        else
2101
                                                cmsDoTransform(xform, ptr, ptr, width());
2102
                                }
2004 fschmid 2103
                                // if transforming from CMYK to RGB, flatten the alpha channel
2104
                                // which will still contain the black channel
6850 fschmid 2105
                                if (!((ext == "psd") || (ext == "tif") || (ext == "tiff")))
2004 fschmid 2106
                                {
7175 fschmid 2107
                                        QRgb alphaFF = qRgba(0,