← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/digikam/intrepid

« back to all changes in this revision

Viewing changes to digikam/imageplugins/coreplugin/sharpnesseditor/imageeffect_sharpen.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mark Purcell
  • Date: 2008-07-17 20:25:39 UTC
  • mfrom: (1.2.15 upstream) (3.1.2 lenny)
  • Revision ID: james.westby@ubuntu.com-20080717202539-6n7dtirbkoo7qvhd
Tags: 2:0.9.4-1
http://bugs.debian.org/490144
* New upstream release
  - digiKam 0.9.4 Release Plan (KDE3) ~ 13 July 08 (Closes: #490144)
* DEB_CONFIGURE_EXTRA_FLAGS := --without-included-sqlite3
* Debhelper compatibility level V7
* Install pixmaps in debian/*.install
* Add debian/digikam.lintian-overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
digikam/imageplugins/coreplugin/sharpnesseditor/imageeffect_sharpen.cpp
13
13
 * Public License as published by the Free Software Foundation;
14
14
 * either version 2, or (at your option)
15
15
 * any later version.
16
 
 * 
 
16
 *
17
17
 * This program is distributed in the hope that it will be useful,
18
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
20
 * GNU General Public License for more details.
21
 
 * 
 
21
 *
22
22
 * ============================================================ */
23
23
 
24
24
#define MAX_MATRIX_SIZE 25
25
25
 
26
 
// C++ includes. 
27
 
 
 
26
// C++ includes.
 
27
 
28
28
#include <cmath>
29
29
 
30
30
// Qt includes.
63
63
{
64
64
 
65
65
ImageEffect_Sharpen::ImageEffect_Sharpen(QWidget* parent)
66
 
                   : Digikam::CtrlPanelDlg(parent, i18n("Sharpening Photograph"), "sharpen",
67
 
                                           true, false, true)
68
 
 {
 
66
        : Digikam::CtrlPanelDlg(parent, i18n("Sharpening Photograph"), "sharpen",
 
67
                                true, true, true)
 
68
{
69
69
    setHelp("blursharpentool.anchor", "digikam");
70
70
 
71
71
    // -------------------------------------------------------------
79
79
    m_sharpMethod->insertItem( i18n("Simple sharp") );
80
80
    m_sharpMethod->insertItem( i18n("Unsharp mask") );
81
81
    m_sharpMethod->insertItem( i18n("Refocus") );
82
 
    QWhatsThis::add( m_sharpMethod, i18n("<p>Select here the sharping method to apply on image."));
83
 
    
 
82
    QWhatsThis::add( m_sharpMethod, i18n("<p>Select the sharpening method to apply to the image."));
 
83
 
84
84
    m_stack = new QWidgetStack(gboxSettings);
85
85
 
86
86
    gridSettings->addMultiCellWidget(label1, 0, 0, 0, 0);
89
89
    gridSettings->addMultiCellWidget(m_stack, 2, 2, 0, 1);
90
90
 
91
91
    // -------------------------------------------------------------
92
 
    
 
92
 
93
93
    QWidget *simpleSharpSettings = new QWidget(m_stack);
94
94
    QGridLayout* grid1           = new QGridLayout( simpleSharpSettings, 2, 1, 0, spacingHint());
95
95
 
115
115
    m_radiusInput2 = new KIntNumInput(unsharpMaskSettings);
116
116
    m_radiusInput2->setRange(1, 120, 1, true);
117
117
    QWhatsThis::add( m_radiusInput2, i18n("<p>Radius value is the gaussian blur matrix radius value "
118
 
                                         "used to determines how much to blur the image.") );
119
 
    
 
118
                                          "used to determines how much to blur the image.") );
 
119
 
120
120
    QLabel *label3 = new QLabel(i18n("Amount:"), unsharpMaskSettings);
121
121
    m_amountInput  = new KDoubleNumInput(unsharpMaskSettings);
122
122
    m_amountInput->setPrecision(1);
123
123
    m_amountInput->setRange(0.0, 5.0, 0.1, true);
124
124
    QWhatsThis::add( m_amountInput, i18n("<p>The value of the difference between the "
125
 
                     "original and the blur image that is added back into the original.") );
126
 
    
 
125
                                         "original and the blur image that is added back into the original.") );
 
126
 
127
127
    QLabel *label4   = new QLabel(i18n("Threshold:"), unsharpMaskSettings);
128
128
    m_thresholdInput = new KDoubleNumInput(unsharpMaskSettings);
129
129
    m_thresholdInput->setPrecision(2);
130
130
    m_thresholdInput->setRange(0.0, 1.0, 0.01, true);
131
131
    QWhatsThis::add( m_thresholdInput, i18n("<p>The threshold, as a fraction of the maximum "
132
 
                     "luminosity value, needed to apply the difference amount.") );
 
132
                                            "luminosity value, needed to apply the difference amount.") );
133
133
 
134
134
    grid2->addMultiCellWidget(label2, 0, 0, 0, 1);
135
135
    grid2->addMultiCellWidget(m_radiusInput2, 1, 1, 0, 1);
144
144
 
145
145
    QWidget *refocusSettings = new QWidget(m_stack);
146
146
    QGridLayout* grid3       = new QGridLayout(refocusSettings, 10, 1, 0, spacingHint());
147
 
    
 
147
 
148
148
    QLabel *label5 = new QLabel(i18n("Circular sharpness:"), refocusSettings);
149
149
    m_radius       = new KDoubleNumInput(refocusSettings);
150
150
    m_radius->setPrecision(2);
151
151
    m_radius->setRange(0.0, 5.0, 0.01, true);
152
152
    QWhatsThis::add( m_radius, i18n("<p>This is the radius of the circular convolution. It is the most important "
153
 
                                    "parameter for using the plugin. For most images the default value of 1.0 "
 
153
                                    "parameter for using this plugin. For most images the default value of 1.0 "
154
154
                                    "should give good results. Select a higher value when your image is very blurred."));
155
 
    
 
155
 
156
156
    QLabel *label6 = new QLabel(i18n("Correlation:"), refocusSettings);
157
157
    m_correlation  = new KDoubleNumInput(refocusSettings);
158
158
    m_correlation->setPrecision(2);
177
177
    m_gauss->setPrecision(2);
178
178
    m_gauss->setRange(0.0, 1.0, 0.01, true);
179
179
    QWhatsThis::add( m_gauss, i18n("<p>This is the sharpness for the gaussian convolution. Use this parameter when your "
180
 
                                   "blurring is of gaussian type. In most cases you should set this parameter to 0, because "
181
 
                                   "it causes nasty artifacts. When you use non-zero values you will probably have to "
 
180
                                   "blurring is of a Gaussian type. In most cases you should set this parameter to 0, because "
 
181
                                   "it causes nasty artifacts. When you use non-zero values, you will probably have to "
182
182
                                   "increase the correlation and/or noise filter parameters too."));
183
183
 
184
184
    QLabel *label9 = new QLabel(i18n("Matrix size:"), refocusSettings);
185
185
    m_matrixSize   = new KIntNumInput(refocusSettings);
186
 
    m_matrixSize->setRange(0, MAX_MATRIX_SIZE, 1, true);  
 
186
    m_matrixSize->setRange(0, MAX_MATRIX_SIZE, 1, true);
187
187
    QWhatsThis::add( m_matrixSize, i18n("<p>This parameter determines the size of the transformation matrix. "
188
188
                                        "Increasing the matrix width may give better results, especially when you have "
189
189
                                        "chosen large values for circular or gaussian sharpness."));
200
200
    grid3->addMultiCellWidget(m_matrixSize, 9, 9, 0, 1);
201
201
    grid3->setRowStretch(10, 10);
202
202
    m_stack->addWidget(refocusSettings, Refocus);
203
 
    
 
203
 
204
204
    m_imagePreviewWidget->setUserAreaWidget(gboxSettings);
205
 
        
 
205
 
206
206
    // -------------------------------------------------------------
207
 
    
208
 
    connect(m_radiusInput, SIGNAL(valueChanged (int)),
209
 
            this, SLOT(slotTimer()));
210
 
 
211
 
    connect(m_radiusInput2, SIGNAL(valueChanged (int)),
212
 
            this, SLOT(slotTimer()));                                                
213
 
 
214
 
    connect(m_amountInput, SIGNAL(valueChanged (double)),
215
 
            this, SLOT(slotTimer()));                                                            
216
 
            
217
 
    connect(m_thresholdInput, SIGNAL(valueChanged (double)),
218
 
            this, SLOT(slotTimer()));
219
 
 
220
 
    connect(m_matrixSize, SIGNAL(valueChanged(int)),
221
 
            this, SLOT(slotTimer()));                        
222
 
    
223
 
    connect(m_radius, SIGNAL(valueChanged(double)),
224
 
            this, SLOT(slotTimer()));                        
225
 
 
226
 
    connect(m_gauss, SIGNAL(valueChanged(double)),
227
 
            this, SLOT(slotTimer()));                        
228
 
 
229
 
    connect(m_correlation, SIGNAL(valueChanged(double)),
230
 
            this, SLOT(slotTimer()));                        
231
 
 
232
 
    connect(m_noise, SIGNAL(valueChanged(double)),
233
 
            this, SLOT(slotTimer()));                        
234
207
 
235
208
    connect(m_sharpMethod, SIGNAL(activated(int)),
236
209
            this, SLOT(slotSharpMethodActived(int)));
237
210
 
238
211
    // -------------------------------------------------------------
239
 
    
240
 
    // Image creation with dummy borders (mosaic mode) used by Refocus method. It needs to do 
241
 
    // it before to apply deconvolution filter on original image border pixels including 
 
212
 
 
213
    // Image creation with dummy borders (mosaic mode) used by Refocus method. It needs to do
 
214
    // it before to apply deconvolution filter on original image border pixels including
242
215
    // on matrix size area. This way limit artifacts on image border.
243
 
    
 
216
 
244
217
    Digikam::ImageIface iface(0, 0);
245
 
        
 
218
 
246
219
    uchar* data = iface.getOriginalImage();
247
220
    int    w    = iface.originalWidth();
248
221
    int    h    = iface.originalHeight();
249
222
    bool   sb   = iface.originalSixteenBit();
250
223
    bool   a    = iface.originalHasAlpha();
251
 
    
 
224
 
252
225
    m_img = Digikam::DImg( w + 4*MAX_MATRIX_SIZE, h + 4*MAX_MATRIX_SIZE, sb, a);
253
 
    
 
226
 
254
227
    Digikam::DImg tmp;
255
228
    Digikam::DImg org(w, h, sb, a, data);
256
229
 
257
230
    // Copy original.
258
231
    m_img.bitBltImage(&org, 2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
259
 
   
 
232
 
260
233
    // Create dummy top border
261
234
    tmp = org.copy(0, 0, w, 2*MAX_MATRIX_SIZE);
262
235
    tmp.flip(Digikam::DImg::VERTICAL);
271
244
    tmp = org.copy(0, 0, 2*MAX_MATRIX_SIZE, h);
272
245
    tmp.flip(Digikam::DImg::HORIZONTAL);
273
246
    m_img.bitBltImage(&tmp, 0, 2*MAX_MATRIX_SIZE);
274
 
    
 
247
 
275
248
    // Create dummy right border
276
249
    tmp = org.copy(w-2*MAX_MATRIX_SIZE, 0, 2*MAX_MATRIX_SIZE, h);
277
250
    tmp.flip(Digikam::DImg::HORIZONTAL);
278
251
    m_img.bitBltImage(&tmp, w+2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
279
 
    
 
252
 
280
253
    // Create dummy top/left corner
281
254
    tmp = org.copy(0, 0, 2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
282
255
    tmp.flip(Digikam::DImg::HORIZONTAL);
283
256
    tmp.flip(Digikam::DImg::VERTICAL);
284
257
    m_img.bitBltImage(&tmp, 0, 0);
285
 
    
 
258
 
286
259
    // Create dummy top/right corner
287
260
    tmp = org.copy(w-2*MAX_MATRIX_SIZE, 0, 2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
288
261
    tmp.flip(Digikam::DImg::HORIZONTAL);
294
267
    tmp.flip(Digikam::DImg::HORIZONTAL);
295
268
    tmp.flip(Digikam::DImg::VERTICAL);
296
269
    m_img.bitBltImage(&tmp, 0, h+2*MAX_MATRIX_SIZE);
297
 
    
 
270
 
298
271
    // Create dummy bottom/right corner
299
272
    tmp = org.copy(w-2*MAX_MATRIX_SIZE, h-2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
300
273
    tmp.flip(Digikam::DImg::HORIZONTAL);
301
274
    tmp.flip(Digikam::DImg::VERTICAL);
302
275
    m_img.bitBltImage(&tmp, w+2*MAX_MATRIX_SIZE, h+2*MAX_MATRIX_SIZE);
303
 
 
 
276
 
304
277
    delete [] data;
305
278
}
306
279
 
312
285
{
313
286
    switch (m_stack->id(m_stack->visibleWidget()))
314
287
    {
315
 
        case SimpleSharp:
316
 
        {
317
 
            m_radiusInput->setEnabled(true);
318
 
            enableButton(User2, false);
319
 
            enableButton(User3, false);
320
 
            break;
321
 
        }
322
 
 
323
 
        case UnsharpMask:
324
 
        {
325
 
            m_radiusInput2->setEnabled(true);
326
 
            m_amountInput->setEnabled(true);
327
 
            m_thresholdInput->setEnabled(true);
328
 
            enableButton(User2, false);
329
 
            enableButton(User3, false);
330
 
            break;
331
 
        }
332
 
 
333
 
        case Refocus:
334
 
        {
335
 
            m_matrixSize->setEnabled(true);
336
 
            m_radius->setEnabled(true);
337
 
            m_gauss->setEnabled(true);
338
 
            m_correlation->setEnabled(true);
339
 
            m_noise->setEnabled(true);
340
 
            break;
341
 
        }
 
288
    case SimpleSharp:
 
289
    {
 
290
        m_radiusInput->setEnabled(true);
 
291
        enableButton(User2, false);
 
292
        enableButton(User3, false);
 
293
        break;
 
294
    }
 
295
 
 
296
    case UnsharpMask:
 
297
    {
 
298
        m_radiusInput2->setEnabled(true);
 
299
        m_amountInput->setEnabled(true);
 
300
        m_thresholdInput->setEnabled(true);
 
301
        enableButton(User2, false);
 
302
        enableButton(User3, false);
 
303
        break;
 
304
    }
 
305
 
 
306
    case Refocus:
 
307
    {
 
308
        m_matrixSize->setEnabled(true);
 
309
        m_radius->setEnabled(true);
 
310
        m_gauss->setEnabled(true);
 
311
        m_correlation->setEnabled(true);
 
312
        m_noise->setEnabled(true);
 
313
        break;
 
314
    }
342
315
    }
343
316
}
344
317
 
355
328
        enableButton(User2, false);
356
329
        enableButton(User3, false);
357
330
    }
358
 
 
359
 
    slotEffect();
360
331
}
361
332
 
362
333
void ImageEffect_Sharpen::readUserSettings()
417
388
{
418
389
    switch (m_stack->id(m_stack->visibleWidget()))
419
390
    {
420
 
        case SimpleSharp:
421
 
        {    
422
 
            m_radiusInput->blockSignals(true);
423
 
            m_radiusInput->setValue(0);
424
 
            m_radiusInput->blockSignals(false);
425
 
            break;
426
 
        }
427
 
 
428
 
        case UnsharpMask:
429
 
        {
430
 
            m_radiusInput2->blockSignals(true);
431
 
            m_amountInput->blockSignals(true);
432
 
            m_thresholdInput->blockSignals(true);
433
 
            m_radiusInput2->setValue(1);
434
 
            m_amountInput->setValue(1.0);
435
 
            m_thresholdInput->setValue(0.05);
436
 
            m_radiusInput2->blockSignals(false);
437
 
            m_amountInput->blockSignals(false);
438
 
            m_thresholdInput->blockSignals(false);
439
 
            break;
440
 
        }
441
 
 
442
 
        case Refocus:
443
 
        {
444
 
            m_matrixSize->blockSignals(true);
445
 
            m_radius->blockSignals(true);
446
 
            m_gauss->blockSignals(true);
447
 
            m_correlation->blockSignals(true);
448
 
            m_noise->blockSignals(true);
449
 
            m_matrixSize->setValue(5);
450
 
            m_radius->setValue(1.0);
451
 
            m_gauss->setValue(0.0);
452
 
            m_correlation->setValue(0.5);
453
 
            m_noise->setValue(0.03);
454
 
            m_matrixSize->blockSignals(false);
455
 
            m_radius->blockSignals(false);
456
 
            m_gauss->blockSignals(false);
457
 
            m_correlation->blockSignals(false);
458
 
            m_noise->blockSignals(false);
459
 
            break;
460
 
        }    
461
 
    }
462
 
} 
 
391
    case SimpleSharp:
 
392
    {
 
393
        m_radiusInput->blockSignals(true);
 
394
        m_radiusInput->setValue(0);
 
395
        m_radiusInput->blockSignals(false);
 
396
        break;
 
397
    }
 
398
 
 
399
    case UnsharpMask:
 
400
    {
 
401
        m_radiusInput2->blockSignals(true);
 
402
        m_amountInput->blockSignals(true);
 
403
        m_thresholdInput->blockSignals(true);
 
404
        m_radiusInput2->setValue(1);
 
405
        m_amountInput->setValue(1.0);
 
406
        m_thresholdInput->setValue(0.05);
 
407
        m_radiusInput2->blockSignals(false);
 
408
        m_amountInput->blockSignals(false);
 
409
        m_thresholdInput->blockSignals(false);
 
410
        break;
 
411
    }
 
412
 
 
413
    case Refocus:
 
414
    {
 
415
        m_matrixSize->blockSignals(true);
 
416
        m_radius->blockSignals(true);
 
417
        m_gauss->blockSignals(true);
 
418
        m_correlation->blockSignals(true);
 
419
        m_noise->blockSignals(true);
 
420
        m_matrixSize->setValue(5);
 
421
        m_radius->setValue(1.0);
 
422
        m_gauss->setValue(0.0);
 
423
        m_correlation->setValue(0.5);
 
424
        m_noise->setValue(0.03);
 
425
        m_matrixSize->blockSignals(false);
 
426
        m_radius->blockSignals(false);
 
427
        m_gauss->blockSignals(false);
 
428
        m_correlation->blockSignals(false);
 
429
        m_noise->blockSignals(false);
 
430
        break;
 
431
    }
 
432
    }
 
433
}
463
434
 
464
435
void ImageEffect_Sharpen::prepareEffect()
465
436
{
466
437
    switch (m_stack->id(m_stack->visibleWidget()))
467
438
    {
468
 
        case SimpleSharp:
469
 
        {    
470
 
            m_radiusInput->setEnabled(false);
471
 
            
472
 
            Digikam::DImg img = m_imagePreviewWidget->getOriginalRegionImage();
473
 
                
474
 
            double radius = m_radiusInput->value()/10.0;
475
 
            double sigma;
476
 
        
477
 
            if (radius < 1.0) sigma = radius;
478
 
            else sigma = sqrt(radius);
479
 
            
480
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
481
 
                               (new Digikam::DImgSharpen(&img, this, radius, sigma ));
482
 
            break;
483
 
        }
484
 
 
485
 
        case UnsharpMask:
486
 
        {
487
 
            m_radiusInput2->setEnabled(false);
488
 
            m_amountInput->setEnabled(false);
489
 
            m_thresholdInput->setEnabled(false);
490
 
            
491
 
            Digikam::DImg img = m_imagePreviewWidget->getOriginalRegionImage();
492
 
        
493
 
            int    r  = m_radiusInput2->value();
494
 
            double a  = m_amountInput->value();
495
 
            double th = m_thresholdInput->value();
496
 
            
497
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
498
 
                               (new DigikamImagesPluginCore::UnsharpMask(&img, this, r, a, th));
499
 
            break;
500
 
        }
501
 
 
502
 
        case Refocus:
503
 
        {
504
 
            m_matrixSize->setEnabled(false);
505
 
            m_radius->setEnabled(false);
506
 
            m_gauss->setEnabled(false);
507
 
            m_correlation->setEnabled(false);
508
 
            m_noise->setEnabled(false);
509
 
            
510
 
            int    ms     = m_matrixSize->value();
511
 
            double r      = m_radius->value();
512
 
            double g      = m_gauss->value();
513
 
            double c      = m_correlation->value();
514
 
            double n      = m_noise->value();
515
 
        
516
 
            QRect area    = m_imagePreviewWidget->getOriginalImageRegionToRender();
517
 
            QRect tmpRect;
518
 
            tmpRect.setLeft(area.left()-2*ms);
519
 
            tmpRect.setRight(area.right()+2*ms);
520
 
            tmpRect.setTop(area.top()-2*ms);
521
 
            tmpRect.setBottom(area.bottom()+2*ms);
522
 
            tmpRect.moveBy(2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
523
 
            Digikam::DImg imTemp = m_img.copy(tmpRect);
524
 
                
525
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
526
 
                               (new DigikamImagesPluginCore::Refocus(&imTemp, this, ms, r, g, c, n));
527
 
            break;
528
 
        }
529
 
    }        
 
439
    case SimpleSharp:
 
440
    {
 
441
        m_radiusInput->setEnabled(false);
 
442
 
 
443
        Digikam::DImg img = m_imagePreviewWidget->getOriginalRegionImage();
 
444
 
 
445
        double radius = m_radiusInput->value()/10.0;
 
446
        double sigma;
 
447
 
 
448
        if (radius < 1.0) sigma = radius;
 
449
        else sigma = sqrt(radius);
 
450
 
 
451
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
452
                           (new Digikam::DImgSharpen(&img, this, radius, sigma ));
 
453
        break;
 
454
    }
 
455
 
 
456
    case UnsharpMask:
 
457
    {
 
458
        m_radiusInput2->setEnabled(false);
 
459
        m_amountInput->setEnabled(false);
 
460
        m_thresholdInput->setEnabled(false);
 
461
 
 
462
        Digikam::DImg img = m_imagePreviewWidget->getOriginalRegionImage();
 
463
 
 
464
        int    r  = m_radiusInput2->value();
 
465
        double a  = m_amountInput->value();
 
466
        double th = m_thresholdInput->value();
 
467
 
 
468
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
469
                           (new DigikamImagesPluginCore::UnsharpMask(&img, this, r, a, th));
 
470
        break;
 
471
    }
 
472
 
 
473
    case Refocus:
 
474
    {
 
475
        m_matrixSize->setEnabled(false);
 
476
        m_radius->setEnabled(false);
 
477
        m_gauss->setEnabled(false);
 
478
        m_correlation->setEnabled(false);
 
479
        m_noise->setEnabled(false);
 
480
 
 
481
        int    ms     = m_matrixSize->value();
 
482
        double r      = m_radius->value();
 
483
        double g      = m_gauss->value();
 
484
        double c      = m_correlation->value();
 
485
        double n      = m_noise->value();
 
486
 
 
487
        QRect area    = m_imagePreviewWidget->getOriginalImageRegionToRender();
 
488
        QRect tmpRect;
 
489
        tmpRect.setLeft(area.left()-2*ms);
 
490
        tmpRect.setRight(area.right()+2*ms);
 
491
        tmpRect.setTop(area.top()-2*ms);
 
492
        tmpRect.setBottom(area.bottom()+2*ms);
 
493
        tmpRect.moveBy(2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE);
 
494
        Digikam::DImg imTemp = m_img.copy(tmpRect);
 
495
 
 
496
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
497
                           (new DigikamImagesPluginCore::Refocus(&imTemp, this, ms, r, g, c, n));
 
498
        break;
 
499
    }
 
500
    }
530
501
}
531
502
 
532
503
void ImageEffect_Sharpen::prepareFinal()
533
504
{
534
505
    switch (m_stack->id(m_stack->visibleWidget()))
535
506
    {
536
 
        case SimpleSharp:
537
 
        {    
538
 
            m_radiusInput->setEnabled(false);
539
 
        
540
 
            double radius = m_radiusInput->value()/10.0;
541
 
            double sigma;
542
 
        
543
 
            if (radius < 1.0) sigma = radius;
544
 
            else sigma = sqrt(radius);
545
 
            
546
 
            Digikam::ImageIface iface(0, 0);
547
 
            uchar *data     = iface.getOriginalImage();
548
 
            int w           = iface.originalWidth();
549
 
            int h           = iface.originalHeight();
550
 
            bool sixteenBit = iface.originalSixteenBit();
551
 
            bool hasAlpha   = iface.originalHasAlpha();
552
 
            Digikam::DImg orgImage = Digikam::DImg(w, h, sixteenBit, hasAlpha ,data);
553
 
            delete [] data;
554
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
555
 
                               (new Digikam::DImgSharpen(&orgImage, this, radius, sigma ));
556
 
            break;
557
 
        }
558
 
 
559
 
        case UnsharpMask:
560
 
        {
561
 
            m_radiusInput2->setEnabled(false);
562
 
            m_amountInput->setEnabled(false);
563
 
            m_thresholdInput->setEnabled(false);
564
 
                
565
 
            int    r  = m_radiusInput2->value();
566
 
            double a  = m_amountInput->value();
567
 
            double th = m_thresholdInput->value();
568
 
            
569
 
            Digikam::ImageIface iface(0, 0);
570
 
            uchar *data     = iface.getOriginalImage();
571
 
            int w           = iface.originalWidth();
572
 
            int h           = iface.originalHeight();
573
 
            bool sixteenBit = iface.originalSixteenBit();
574
 
            bool hasAlpha   = iface.originalHasAlpha();
575
 
            Digikam::DImg orgImage = Digikam::DImg(w, h, sixteenBit, hasAlpha ,data);
576
 
            delete [] data;
577
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
578
 
                               (new DigikamImagesPluginCore::UnsharpMask(&orgImage, this, r, a, th));
579
 
            break;
580
 
        }
581
 
 
582
 
        case Refocus:
583
 
        {
584
 
 
585
 
            m_matrixSize->setEnabled(false);
586
 
            m_radius->setEnabled(false);
587
 
            m_gauss->setEnabled(false);
588
 
            m_correlation->setEnabled(false);
589
 
            m_noise->setEnabled(false);
590
 
            
591
 
            int    ms   = m_matrixSize->value();
592
 
            double r    = m_radius->value();
593
 
            double g    = m_gauss->value();
594
 
            double c    = m_correlation->value();
595
 
            double n    = m_noise->value();
596
 
            
597
 
            m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
598
 
                               (new DigikamImagesPluginCore::Refocus(&m_img, this, ms, r, g, c, n));
599
 
            break;
600
 
        }
601
 
    }        
 
507
    case SimpleSharp:
 
508
    {
 
509
        m_radiusInput->setEnabled(false);
 
510
 
 
511
        double radius = m_radiusInput->value()/10.0;
 
512
        double sigma;
 
513
 
 
514
        if (radius < 1.0) sigma = radius;
 
515
        else sigma = sqrt(radius);
 
516
 
 
517
        Digikam::ImageIface iface(0, 0);
 
518
        uchar *data     = iface.getOriginalImage();
 
519
        int w           = iface.originalWidth();
 
520
        int h           = iface.originalHeight();
 
521
        bool sixteenBit = iface.originalSixteenBit();
 
522
        bool hasAlpha   = iface.originalHasAlpha();
 
523
        Digikam::DImg orgImage = Digikam::DImg(w, h, sixteenBit, hasAlpha ,data);
 
524
        delete [] data;
 
525
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
526
                           (new Digikam::DImgSharpen(&orgImage, this, radius, sigma ));
 
527
        break;
 
528
    }
 
529
 
 
530
    case UnsharpMask:
 
531
    {
 
532
        m_radiusInput2->setEnabled(false);
 
533
        m_amountInput->setEnabled(false);
 
534
        m_thresholdInput->setEnabled(false);
 
535
 
 
536
        int    r  = m_radiusInput2->value();
 
537
        double a  = m_amountInput->value();
 
538
        double th = m_thresholdInput->value();
 
539
 
 
540
        Digikam::ImageIface iface(0, 0);
 
541
        uchar *data     = iface.getOriginalImage();
 
542
        int w           = iface.originalWidth();
 
543
        int h           = iface.originalHeight();
 
544
        bool sixteenBit = iface.originalSixteenBit();
 
545
        bool hasAlpha   = iface.originalHasAlpha();
 
546
        Digikam::DImg orgImage = Digikam::DImg(w, h, sixteenBit, hasAlpha ,data);
 
547
        delete [] data;
 
548
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
549
                           (new DigikamImagesPluginCore::UnsharpMask(&orgImage, this, r, a, th));
 
550
        break;
 
551
    }
 
552
 
 
553
    case Refocus:
 
554
    {
 
555
 
 
556
        m_matrixSize->setEnabled(false);
 
557
        m_radius->setEnabled(false);
 
558
        m_gauss->setEnabled(false);
 
559
        m_correlation->setEnabled(false);
 
560
        m_noise->setEnabled(false);
 
561
 
 
562
        int    ms   = m_matrixSize->value();
 
563
        double r    = m_radius->value();
 
564
        double g    = m_gauss->value();
 
565
        double c    = m_correlation->value();
 
566
        double n    = m_noise->value();
 
567
 
 
568
        m_threadedFilter = dynamic_cast<Digikam::DImgThreadedFilter *>
 
569
                           (new DigikamImagesPluginCore::Refocus(&m_img, this, ms, r, g, c, n));
 
570
        break;
 
571
    }
 
572
    }
602
573
}
603
574
 
604
575
void ImageEffect_Sharpen::putPreviewData(void)
605
576
{
606
577
    switch (m_stack->id(m_stack->visibleWidget()))
607
578
    {
608
 
        case SimpleSharp:
609
 
        case UnsharpMask:
610
 
        {    
611
 
            Digikam::DImg imDest = m_threadedFilter->getTargetImage();
612
 
            m_imagePreviewWidget->setPreviewImage(imDest);
613
 
            break;
614
 
        }
615
 
        
616
 
        case Refocus:
617
 
        {
618
 
            int   ms   = m_matrixSize->value();
619
 
            QRect area = m_imagePreviewWidget->getOriginalImageRegionToRender();
620
 
        
621
 
            Digikam::DImg imDest = m_threadedFilter->getTargetImage()
622
 
                                    .copy(2*ms, 2*ms, area.width(), area.height());
623
 
            m_imagePreviewWidget->setPreviewImage(imDest);
624
 
            break;
625
 
        }
 
579
    case SimpleSharp:
 
580
    case UnsharpMask:
 
581
    {
 
582
        Digikam::DImg imDest = m_threadedFilter->getTargetImage();
 
583
        m_imagePreviewWidget->setPreviewImage(imDest);
 
584
        break;
 
585
    }
 
586
 
 
587
    case Refocus:
 
588
    {
 
589
        int   ms   = m_matrixSize->value();
 
590
        QRect area = m_imagePreviewWidget->getOriginalImageRegionToRender();
 
591
 
 
592
        Digikam::DImg imDest = m_threadedFilter->getTargetImage()
 
593
                               .copy(2*ms, 2*ms, area.width(), area.height());
 
594
        m_imagePreviewWidget->setPreviewImage(imDest);
 
595
        break;
 
596
    }
626
597
    }
627
598
}
628
599
 
633
604
 
634
605
    switch (m_stack->id(m_stack->visibleWidget()))
635
606
    {
636
 
        case SimpleSharp:
637
 
        {
638
 
            iface.putOriginalImage(i18n("Sharpen"), imDest.bits());
639
 
            break;
640
 
        }
641
 
 
642
 
        case UnsharpMask:
643
 
        {
644
 
            iface.putOriginalImage(i18n("Unsharp Mask"), imDest.bits());
645
 
            break;
646
 
        }
647
 
        
648
 
        case Refocus:
649
 
        {
650
 
            QRect area = m_imagePreviewWidget->getOriginalImageRegionToRender();
651
 
            Digikam::ImageIface iface(0, 0);
652
 
        
653
 
            iface.putOriginalImage(i18n("Refocus"), m_threadedFilter->getTargetImage()
654
 
                                                        .copy(2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE,
655
 
                                                                iface.originalWidth(),
656
 
                                                                iface.originalHeight())
657
 
                                                        .bits());
658
 
            break;
659
 
        }
 
607
    case SimpleSharp:
 
608
    {
 
609
        iface.putOriginalImage(i18n("Sharpen"), imDest.bits());
 
610
        break;
 
611
    }
 
612
 
 
613
    case UnsharpMask:
 
614
    {
 
615
        iface.putOriginalImage(i18n("Unsharp Mask"), imDest.bits());
 
616
        break;
 
617
    }
 
618
 
 
619
    case Refocus:
 
620
    {
 
621
        QRect area = m_imagePreviewWidget->getOriginalImageRegionToRender();
 
622
        Digikam::ImageIface iface(0, 0);
 
623
 
 
624
        iface.putOriginalImage(i18n("Refocus"), m_threadedFilter->getTargetImage()
 
625
                               .copy(2*MAX_MATRIX_SIZE, 2*MAX_MATRIX_SIZE,
 
626
                                     iface.originalWidth(),
 
627
                                     iface.originalHeight())
 
628
                               .bits());
 
629
        break;
 
630
    }
660
631
    }
661
632
}
662
633
 
663
634
void ImageEffect_Sharpen::slotUser3()
664
635
{
665
636
    KURL loadRestorationFile = KFileDialog::getOpenURL(KGlobalSettings::documentPath(),
666
 
                                            QString( "*" ), this,
667
 
                                            QString( i18n("Photograph Refocus Settings File to Load")) );
668
 
    if( loadRestorationFile.isEmpty() )
669
 
       return;
 
637
                               QString( "*" ), this,
 
638
                               QString( i18n("Photograph Refocus Settings File to Load")) );
 
639
    if ( loadRestorationFile.isEmpty() )
 
640
        return;
670
641
 
671
642
    QFile file(loadRestorationFile.path());
672
 
    
673
 
    if ( file.open(IO_ReadOnly) )   
 
643
 
 
644
    if ( file.open(IO_ReadOnly) )
674
645
    {
675
646
        QTextStream stream( &file );
676
647
        if ( stream.readLine() != "# Photograph Refocus Configuration File" )
677
648
        {
678
 
           KMessageBox::error(this, 
679
 
                        i18n("\"%1\" is not a Photograph Refocus settings text file.")
680
 
                        .arg(loadRestorationFile.fileName()));
681
 
           file.close();            
682
 
           return;
 
649
            KMessageBox::error(this,
 
650
                               i18n("\"%1\" is not a Photograph Refocus settings text file.")
 
651
                               .arg(loadRestorationFile.fileName()));
 
652
            file.close();
 
653
            return;
683
654
        }
684
 
        
 
655
 
685
656
        blockSignals(true);
686
657
        m_matrixSize->setValue( stream.readLine().toInt() );
687
658
        m_radius->setValue( stream.readLine().toDouble() );
689
660
        m_correlation->setValue( stream.readLine().toDouble() );
690
661
        m_noise->setValue( stream.readLine().toDouble() );
691
662
        blockSignals(false);
692
 
        slotEffect();  
693
663
    }
694
664
    else
695
665
        KMessageBox::error(this, i18n("Cannot load settings from the Photograph Refocus text file."));
696
666
 
697
 
    file.close();             
 
667
    file.close();
698
668
}
699
669
 
700
670
void ImageEffect_Sharpen::slotUser2()
701
671
{
702
672
    KURL saveRestorationFile = KFileDialog::getSaveURL(KGlobalSettings::documentPath(),
703
 
                                            QString( "*" ), this,
704
 
                                            QString( i18n("Photograph Refocus Settings File to Save")) );
705
 
    if( saveRestorationFile.isEmpty() )
706
 
       return;
 
673
                               QString( "*" ), this,
 
674
                               QString( i18n("Photograph Refocus Settings File to Save")) );
 
675
    if ( saveRestorationFile.isEmpty() )
 
676
        return;
707
677
 
708
678
    QFile file(saveRestorationFile.path());
709
 
    
710
 
    if ( file.open(IO_WriteOnly) )   
 
679
 
 
680
    if ( file.open(IO_WriteOnly) )
711
681
    {
712
 
        QTextStream stream( &file );        
713
 
        stream << "# Photograph Refocus Configuration File\n";    
714
 
        stream << m_matrixSize->value() << "\n";    
715
 
        stream << m_radius->value() << "\n";    
716
 
        stream << m_gauss->value() << "\n";    
717
 
        stream << m_correlation->value() << "\n";    
718
 
        stream << m_noise->value() << "\n";    
 
682
        QTextStream stream( &file );
 
683
        stream << "# Photograph Refocus Configuration File\n";
 
684
        stream << m_matrixSize->value() << "\n";
 
685
        stream << m_radius->value() << "\n";
 
686
        stream << m_gauss->value() << "\n";
 
687
        stream << m_correlation->value() << "\n";
 
688
        stream << m_noise->value() << "\n";
719
689
    }
720
690
    else
721
691
        KMessageBox::error(this, i18n("Cannot save settings to the Photograph Refocus text file."));
722
 
    
723
 
    file.close();        
 
692
 
 
693
    file.close();
724
694
}
725
695
 
726
696
}  // NameSpace DigikamImagesPluginCore