Subversion Repositories Scribus

Rev

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

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