← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to libs/dimg/filters/nr/nrfilter.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-21 23:19:11 UTC
  • mfrom: (1.2.33 upstream) (3.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20101221231911-z9jip7s5aht1jqn9
Tags: 2:1.7.0-1ubuntu1
* Merge from Debian Experimental. Remaining Ubuntu changes:
  - Export .pot name and copy to plugins in debian/rules
  - Version build-depends on kipi-plugins-dev to ensure build is against the
    same version on all archs
* Drop debian/patches/kubuntu_01_linker.diff, incoporated upstream
* Remove patches directory and unused patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/dimg/filters/nr/nrfilter.cpp
57
57
};
58
58
 
59
59
NRFilter::NRFilter(DImg* orgImage, QObject* parent, const NRContainer& settings)
60
 
        : DImgThreadedFilter(orgImage, parent, "NRFilter"),
61
 
          d(new NRFilterPriv)
 
60
    : DImgThreadedFilter(orgImage, parent, "NRFilter"),
 
61
      d(new NRFilterPriv)
62
62
{
63
63
    d->settings = settings;
64
64
 
83
83
    // Allocate buffers.
84
84
 
85
85
    for (int c = 0; c < 3; c++)
 
86
    {
86
87
        d->fimg[c] = new float[width * height];
 
88
    }
87
89
 
88
90
    d->buffer[1] = new float[width * height];
89
91
    d->buffer[2] = new float[width * height];
126
128
            waveletDenoise(d->buffer, width, height, d->settings.thresholds[c], d->settings.softness[c]);
127
129
 
128
130
            progress = (int) (30.0 + ((double)c * 60.0) / 4);
 
131
 
129
132
            if ( progress%5 == 0 )
 
133
            {
130
134
                postProgress( progress );
 
135
            }
131
136
        }
132
137
    }
133
138
 
175
180
    // Free buffers.
176
181
 
177
182
    for (int c = 0; c < 3; c++)
 
183
    {
178
184
        delete [] d->fimg[c];
 
185
    }
179
186
 
180
187
    delete [] d->buffer[1];
181
188
    delete [] d->buffer[2];
197
204
    for (lev = 0; runningFlag() && (lev < 5); ++lev)
198
205
    {
199
206
        lpass = ((lev & 1) + 1);
 
207
 
200
208
        for (row = 0; runningFlag() && (row < height); ++row)
201
209
        {
202
210
            hatTransform(temp, fimg[hpass] + row * width, 1, width, 1 << lev);
 
211
 
203
212
            for (col = 0; col < width; ++col)
204
213
            {
205
 
                fimg[lpass][row * width + col] = temp[col] * 0.25;
 
214
                fimg[lpass][row* width + col] = temp[col] * 0.25;
206
215
            }
207
216
        }
208
217
 
209
218
        for (col = 0; runningFlag() && (col < width); ++col)
210
219
        {
211
220
            hatTransform(temp, fimg[lpass] + col, width, height, 1 << lev);
 
221
 
212
222
            for (row = 0; row < height; ++row)
213
223
            {
214
 
                fimg[lpass][row * width + col] = temp[row] * 0.25;
 
224
                fimg[lpass][row* width + col] = temp[row] * 0.25;
215
225
            }
216
226
        }
217
227
 
290
300
            }
291
301
 
292
302
            if (fimg[hpass][i] < -thold)
 
303
            {
293
304
                fimg[hpass][i] += thold - thold * softness;
 
305
            }
294
306
            else if (fimg[hpass][i] > thold)
 
307
            {
295
308
                fimg[hpass][i] -= thold - thold * softness;
 
309
            }
296
310
            else
 
311
            {
297
312
                fimg[hpass][i] *= softness;
 
313
            }
298
314
 
299
315
            if (hpass)
 
316
            {
300
317
                fimg[0][i] += fimg[hpass][i];
 
318
            }
301
319
        }
302
320
 
303
321
        hpass = lpass;
304
322
    }
305
323
 
306
324
    for (i = 0; runningFlag() && (i < size); ++i)
 
325
    {
307
326
        fimg[0][i] = fimg[0][i] + fimg[lpass][i];
 
327
    }
308
328
 
309
329
    delete [] temp;
310
330
}
314
334
    int i;
315
335
 
316
336
    for (i = 0; i < sc; i++)
317
 
      temp[i] = 2 * base[st * i] + base[st * (sc - i)] + base[st * (i + sc)];
 
337
    {
 
338
        temp[i] = 2 * base[st * i] + base[st * (sc - i)] + base[st * (i + sc)];
 
339
    }
318
340
 
319
341
    for (; i + sc < size; i++)
320
 
      temp[i] = 2 * base[st * i] + base[st * (i - sc)] + base[st * (i + sc)];
 
342
    {
 
343
        temp[i] = 2 * base[st * i] + base[st * (i - sc)] + base[st * (i + sc)];
 
344
    }
321
345
 
322
346
    for (; i < size; i++)
323
 
      temp[i] = 2 * base[st * i] + base[st * (i - sc)] + base[st * (2 * size - 2 - (i + sc))];
 
347
    {
 
348
        temp[i] = 2 * base[st * i] + base[st * (i - sc)] + base[st * (2 * size - 2 - (i + sc))];
 
349
    }
324
350
}
325
351
 
326
352
// -- Color Space conversion methods --------------------------------------------------
433
459
 
434
460
        /* scale */
435
461
        if (x * x * x > 216 / 24389.0)
 
462
        {
436
463
            x = x * x * x;
 
464
        }
437
465
        else
 
466
        {
438
467
            x = (116 * x - 16) * 27 / 24389.0;
 
468
        }
 
469
 
439
470
        if (fimg[0][i] > 216 / 27.0)
 
471
        {
440
472
            y = y * y * y;
 
473
        }
441
474
        else
442
475
            /*y = fimg[0][i] * 27 / 24389.0;*/
 
476
        {
443
477
            y = (116 * y - 16) * 27 / 24389.0;
 
478
        }
 
479
 
444
480
        if (z * z * z > 216 / 24389.0)
 
481
        {
445
482
            z = z * z * z;
 
483
        }
446
484
        else
 
485
        {
447
486
            z = (116 * z - 16) * 27 / 24389.0;
 
487
        }
448
488
 
449
489
        /* white reference */
450
490
        fimg[0][i] = x * 0.95047;
505
545
        fimg[2][i] = b / 200.0 / 2.2 + 0.5;
506
546
 
507
547
        if (fimg[0][i] < 0)
 
548
        {
508
549
            fimg[0][i] = 0;
 
550
        }
509
551
    }
510
552
}
511
553