← Back to branch summary

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

« back to all changes in this revision

Viewing changes to imageplugins/localcontrast/tonemappingparameters.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christian Mangold
  • Date: 2010-04-09 21:30:01 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100409213001-4bfyibrd359rn7o3
Tags: 2:1.2.0-0ubuntu1
https://launchpad.net/bugs/560576
* New upstream release (LP: #560576)
* Remove all patches, fixed upstream
  - Remove quilt build-depend

Show diffs side-by-side

added added

removed removed

Lines of Context:
imageplugins/localcontrast/tonemappingparameters.cpp
1
 
/* ============================================================
2
 
 *
3
 
 * This file is a part of digiKam project
4
 
 * http://www.digikam.org
5
 
 *
6
 
 * Date        : 2009-08-09
7
 
 * Description : LDR ToneMapper <http://zynaddsubfx.sourceforge.net/other/tonemapping>.
8
 
 *
9
 
 * Copyright (C) 2009 by Nasca Octavian Paul <zynaddsubfx at yahoo dot com>
10
 
 * Copyright (C) 2009 by Gilles Caulier <caulier dot gilles at gmail dot com>
11
 
 *
12
 
 * This program is free software; you can redistribute it
13
 
 * and/or modify it under the terms of the GNU General
14
 
 * Public License as published by the Free Software Foundation;
15
 
 * either version 2, or (at your option)
16
 
 * any later version.
17
 
 *
18
 
 * This program is distributed in the hope that it will be useful,
19
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
 
 * GNU General Public License for more details.
22
 
 *
23
 
 * ============================================================ */
24
 
 
25
 
// C++ includes.
26
 
 
27
 
#include <cstdio>
28
 
#include <cstring>
29
 
#include <cstdlib>
30
 
#include <cmath>
31
 
 
32
 
// KDE includes
33
 
 
34
 
#include <kdebug.h>
35
 
 
36
 
// Local includes.
37
 
 
38
 
#include "tonemappingparameters.h"
39
 
 
40
 
#ifdef Q_CC_MSVC
41
 
        #pragma warning ( disable : 4800 )      // forcing value to bool 'true' or 'false' (performance warning)
42
 
#endif
43
 
 
44
 
namespace DigikamLocalContrastImagesPlugin
45
 
{
46
 
 
47
 
class ToneMappingParametersPriv
48
 
{
49
 
public:
50
 
 
51
 
    ToneMappingParametersPriv()
52
 
    {
53
 
        cancel   = 0;
54
 
        data     = 0;
55
 
        callBack = 0;
56
 
    };
57
 
 
58
 
    /** To cancel computation from user interface.
59
 
    */
60
 
    bool*                  cancel;
61
 
 
62
 
    /** For progress CallBack method from User interface
63
 
     */
64
 
    ToneMappingCallbackPtr callBack;
65
 
    void*                  data;  
66
 
};  
67
 
    
68
 
ToneMappingParameters::ToneMappingParameters()
69
 
{
70
 
    d = new ToneMappingParametersPriv;
71
 
    
72
 
    info_fast_mode   = true;
73
 
    high_saturation  = 100;
74
 
    low_saturation   = 100;
75
 
    stretch_contrast = true;
76
 
    function_id      = 0;
77
 
 
78
 
    for (int i = 0 ; i < TONEMAPPING_MAX_STAGES ; i++)
79
 
    {
80
 
        stage[i].enabled = (i == 0);
81
 
        stage[i].power   = 30.0;
82
 
        stage[i].blur    = 80.0;
83
 
    }
84
 
 
85
 
    unsharp_mask.enabled   = false;
86
 
    unsharp_mask.power     = 30.0;
87
 
    unsharp_mask.blur      = 4.0;
88
 
    unsharp_mask.threshold = 0;
89
 
}
90
 
 
91
 
ToneMappingParameters::~ToneMappingParameters()
92
 
{
93
 
    delete d;
94
 
}
95
 
 
96
 
ToneMappingParameters& ToneMappingParameters::operator=(const ToneMappingParameters& prm)
97
 
{
98
 
    d = prm.d;
99
 
    return *this;
100
 
}
101
 
 
102
 
bool ToneMappingParameters::cancel()
103
 
{
104
 
    if (d->cancel)
105
 
        return *d->cancel;
106
 
 
107
 
    return false;
108
 
}
109
 
 
110
 
void ToneMappingParameters::setCancel(bool* b)
111
 
{
112
 
    d->cancel = b;
113
 
}
114
 
 
115
 
void ToneMappingParameters::setProgressCallBackFunction(void* data, ToneMappingCallbackPtr cb)
116
 
{
117
 
    d->callBack = cb;
118
 
    d->data     = data;
119
 
}
120
 
 
121
 
void ToneMappingParameters::postProgress(int progress)
122
 
{
123
 
    d->callBack(d->data, progress);
124
 
}
125
 
 
126
 
REALTYPE ToneMappingParameters::get_power(int nstage)
127
 
{
128
 
    REALTYPE power = stage[nstage].power;
129
 
    power          = (REALTYPE)(pow(power/100.0, 1.5)*100.0);
130
 
    return power;
131
 
}
132
 
 
133
 
REALTYPE ToneMappingParameters::get_blur(int nstage)
134
 
{
135
 
    return stage[nstage].blur;
136
 
}
137
 
 
138
 
REALTYPE ToneMappingParameters::get_unsharp_mask_power()
139
 
{
140
 
    REALTYPE power = unsharp_mask.power;
141
 
    power          = (REALTYPE)(pow(power/100.0, 3.0)*10.0);
142
 
    return power;
143
 
}
144
 
 
145
 
REALTYPE ToneMappingParameters::get_unsharp_mask_blur()
146
 
{
147
 
    return unsharp_mask.blur;
148
 
}
149
 
 
150
 
void ToneMappingParameters::save_parameters(const char* filename)
151
 
{
152
 
    FILE *f = fopen(filename, "w");
153
 
    if (!f) return;
154
 
    fprintf(f, "Tonemapping_by_PAUL\n");
155
 
    fprintf(f, "1\n");//version
156
 
 
157
 
    fprintf(f, "info_fast_mode %d\n",   info_fast_mode);
158
 
    fprintf(f, "low_saturation %d\n",   low_saturation);
159
 
    fprintf(f, "high_saturation %d\n",  high_saturation);
160
 
    fprintf(f, "stretch_contrast %d\n", stretch_contrast);
161
 
    fprintf(f, "function_id %d\n",      function_id);
162
 
 
163
 
    for (int i=0 ; i < TONEMAPPING_MAX_STAGES ; i++)
164
 
    {
165
 
        fprintf(f, "STAGE %d\n",   i);
166
 
        fprintf(f, "enabled %d\n", stage[i].enabled);
167
 
        fprintf(f, "power %g\n",   stage[i].power);
168
 
        fprintf(f, "blur %g\n",    stage[i].blur);
169
 
    }
170
 
 
171
 
    fprintf(f, "unsharp_mask_enabled %d\n",   unsharp_mask.enabled);
172
 
    fprintf(f, "unsharp_mask_power %g\n",     unsharp_mask.power);
173
 
    fprintf(f, "unsharp_mask_blur %g\n",      unsharp_mask.blur);
174
 
    fprintf(f, "unsharp_mask_threshold %d\n", unsharp_mask.threshold);
175
 
 
176
 
    fclose(f);
177
 
}
178
 
 
179
 
bool ToneMappingParameters::load_parameters(const char* filename)
180
 
{
181
 
    FILE *f = fopen(filename, "r");
182
 
    if (!f) return false;
183
 
 
184
 
    const int max_line = 1024;
185
 
    char line[max_line];
186
 
    line[0] = 0;
187
 
 
188
 
    fgets(line, max_line, f);
189
 
    if (feof(f)) return false;
190
 
    if (strstr(line, "Tonemapping_by_PAUL") != line) return false;
191
 
    fgets(line, max_line, f);//version
192
 
    int current_stage = 0;
193
 
 
194
 
    while (!feof(f))
195
 
    {
196
 
        for (int i = 0 ; i < max_line ; i++)
197
 
            line[i] = 0;
198
 
 
199
 
        fgets(line, max_line-1,f);
200
 
 
201
 
        if (strlen(line) < 3) continue;
202
 
 
203
 
        int space = 0;
204
 
        for (int i=0 ; i < max_line ; i++)
205
 
        {
206
 
            if (line[i] == ' ')
207
 
            {
208
 
                line[i] = 0;
209
 
                space = i+1;
210
 
                break;
211
 
            }
212
 
        }
213
 
 
214
 
        const char *par  = line;
215
 
        const char *sval = &line[space];
216
 
        int ipar         = atoi(sval);
217
 
        REALTYPE fpar    = (REALTYPE)(atof(sval));
218
 
 
219
 
        if (strstr(par, "info_fast_mode") == par)   info_fast_mode   = ipar;
220
 
        if (strstr(par, "low_saturation") == par)   low_saturation   = ipar;
221
 
        if (strstr(par, "high_saturation") == par)  high_saturation  = ipar;
222
 
        if (strstr(par, "stretch_contrast") == par) stretch_contrast = ipar;
223
 
        if (strstr(par, "function_id") == par)      function_id      = ipar;
224
 
 
225
 
        if (strstr(par, "STAGE") == par)
226
 
        {
227
 
            if (ipar < 0) ipar = 0;
228
 
            if (ipar > (TONEMAPPING_MAX_STAGES-1)) ipar = TONEMAPPING_MAX_STAGES-1;
229
 
            current_stage = ipar;
230
 
        }
231
 
 
232
 
        if (strstr(par, "enabled") == par) stage[current_stage].enabled = ipar;
233
 
        if (strstr(par, "power") == par)   stage[current_stage].power   = fpar;
234
 
        if (strstr(par, "blur") == par)    stage[current_stage].blur    = fpar;
235
 
 
236
 
        if (strstr(par, "unsharp_mask_enabled") == par)   unsharp_mask.enabled   = ipar;
237
 
        if (strstr(par, "unsharp_mask_power") == par)     unsharp_mask.power     = fpar;
238
 
        if (strstr(par, "unsharp_mask_blur") == par)      unsharp_mask.blur      = fpar;
239
 
        if (strstr(par, "unsharp_mask_threshold") == par) unsharp_mask.threshold = ipar;
240
 
    }
241
 
 
242
 
    fclose(f);
243
 
 
244
 
    return true;
245
 
}
246
 
 
247
 
} // namespace DigikamNoiseReductionImagesPlugin