← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to krita/image/kis_math_toolbox.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-09-21 15:36:35 UTC
  • mfrom: (1.4.1 upstream) (60.2.11 maverick)
  • Revision ID: james.westby@ubuntu.com-20100921153635-6tejqkiro2u21ydi
Tags: 1:2.2.2-0ubuntu3
Add kubuntu_03_fix-crash-on-closing-sqlite-connection-2.2.2.diff and
kubuntu_04_support-large-memo-values-for-msaccess-2.2.2.diff as
recommended by upstream http://kexi-
project.org/wiki/wikiview/index.php@Kexi2.2_Patches.html#sqlite_stab
ility

Show diffs side-by-side

added added

removed removed

Lines of Context:
krita/image/kis_math_toolbox.cpp
28
28
 
29
29
#include <QVector>
30
30
 
 
31
#include <KoColorSpaceMaths.h>
31
32
#include <kglobal.h>
32
33
 
33
34
#include <kis_debug.h>
61
62
}
62
63
 
63
64
template<typename T>
64
 
double toDouble(const quint8* data, int channelpos)
 
65
inline double toDouble(const quint8* data, int channelpos)
65
66
{
66
 
    return (float)(*((T*)(data + channelpos)));
 
67
    return (double)(*((T*)(data + channelpos)));
67
68
}
68
69
 
69
 
typedef double(*PtrToDouble)(const quint8*, int);
70
 
 
71
70
template<typename T>
72
71
void fromDouble(quint8* data, int channelpos, double v)
73
72
{
74
73
    *((T*)(data + channelpos)) = (T)v;
75
74
}
76
75
 
77
 
typedef void (*PtrFromDouble)(quint8*, int, double);
78
 
 
79
76
void KisMathToolbox::transformToFR(KisPaintDeviceSP src, KisFloatRepresentation* fr, const QRect& rect)
80
77
{
81
78
    qint32 depth = src->colorSpace()->colorChannelCount();
 
79
    QList<KoChannelInfo *> cis = src->colorSpace()->channels();
 
80
    // remove non-color channels
 
81
    for (qint32 c = 0; c < cis.count(); ++c) {
 
82
        if (cis[c]->channelType() != KoChannelInfo::COLOR)
 
83
            cis.removeAt(c--);
 
84
    }
82
85
    QVector<PtrToDouble> f(depth);
83
 
    QList<KoChannelInfo *> cis = src->colorSpace()->channels();
84
 
    for (qint32 k = 0; k < depth; k++) {
85
 
        switch (cis[k]->channelValueType()) {
86
 
        case KoChannelInfo::UINT8:
87
 
            f[k] = toDouble<quint8>;
88
 
            break;
89
 
        case KoChannelInfo::UINT16:
90
 
            f[k] = toDouble<quint16>;
91
 
            break;
92
 
#ifdef HAVE_OPENEXR
93
 
        case KoChannelInfo::FLOAT16:
94
 
            f[k] = toDouble<half>;
95
 
            break;
96
 
#endif
97
 
        case KoChannelInfo::FLOAT32:
98
 
            f[k] = toDouble<float>;
99
 
            break;
100
 
        case KoChannelInfo::INT8:
101
 
            f[k] = toDouble<qint8>;
102
 
            break;
103
 
        case KoChannelInfo::INT16:
104
 
            f[k] = toDouble<qint16>;
105
 
            break;
106
 
        default:
107
 
            warnKrita << "Unsupported value type in KisMathToolbox";
108
 
            return;
109
 
        }
110
 
    }
 
86
    if (!getToDoubleChannelPtr(cis, f))
 
87
        return;
111
88
 
112
89
    KisHLineConstIteratorPixel srcIt = src->createHLineIterator(rect.x(), rect.y(), rect.width());
113
90
 
125
102
    }
126
103
}
127
104
 
 
105
bool KisMathToolbox::getToDoubleChannelPtr(QList<KoChannelInfo *> cis, QVector<PtrToDouble>& f)
 
106
{
 
107
    qint32 channels = cis.count();
 
108
 
 
109
    for (qint32 k = 0; k < channels; k++) {
 
110
        switch (cis[k]->channelValueType()) {
 
111
        case KoChannelInfo::UINT8:
 
112
            f[k] = toDouble<quint8>;
 
113
            break;
 
114
        case KoChannelInfo::UINT16:
 
115
            f[k] = toDouble<quint16>;
 
116
            break;
 
117
#ifdef HAVE_OPENEXR
 
118
        case KoChannelInfo::FLOAT16:
 
119
            f[k] = toDouble<half>;
 
120
            break;
 
121
#endif
 
122
        case KoChannelInfo::FLOAT32:
 
123
            f[k] = toDouble<float>;
 
124
            break;
 
125
        case KoChannelInfo::INT8:
 
126
            f[k] = toDouble<qint8>;
 
127
            break;
 
128
        case KoChannelInfo::INT16:
 
129
            f[k] = toDouble<qint16>;
 
130
            break;
 
131
        default:
 
132
            warnKrita << "Unsupported value type in KisMathToolbox";
 
133
            return false;
 
134
        }
 
135
    }
 
136
 
 
137
    return true;
 
138
}
 
139
 
128
140
void KisMathToolbox::transformFromFR(KisPaintDeviceSP dst, KisFloatRepresentation* fr, const QRect& rect)
129
141
{
130
142
    qint32 depth = dst->colorSpace()->colorChannelCount();
 
143
    QList<KoChannelInfo *> cis = dst->colorSpace()->channels();
 
144
    // remove non-color channels
 
145
    for (qint32 c = 0; c < cis.count(); ++c) {
 
146
        if (cis[c]->channelType() != KoChannelInfo::COLOR)
 
147
            cis.removeAt(c--);
 
148
    }
 
149
 
131
150
    QVector<PtrFromDouble> f(depth);
132
 
    QList<KoChannelInfo *> cis = dst->colorSpace()->channels();
133
 
    for (qint32 k = 0; k < depth; k++) {
134
 
        switch (cis[k]->channelValueType()) {
135
 
        case KoChannelInfo::UINT8:
136
 
            f[k] = fromDouble<quint8>;
137
 
            break;
138
 
        case KoChannelInfo::UINT16:
139
 
            f[k] = fromDouble<quint16>;
140
 
            break;
141
 
#ifdef HAVE_OPENEXR
142
 
        case KoChannelInfo::FLOAT16:
143
 
            f[k] = fromDouble<half>;
144
 
            break;
145
 
#endif
146
 
        case KoChannelInfo::FLOAT32:
147
 
            f[k] = fromDouble<float>;
148
 
            break;
149
 
        case KoChannelInfo::INT8:
150
 
            f[k] = fromDouble<qint8>;
151
 
            break;
152
 
        case KoChannelInfo::INT16:
153
 
            f[k] = fromDouble<qint16>;
154
 
            break;
155
 
        default:
156
 
            warnKrita << "Unsupported value type in KisMathToolbox";
157
 
            return;
158
 
        }
159
 
    }
 
151
    if (!getFromDoubleChannelPtr(cis, f))
 
152
        return;
160
153
 
161
154
    KisHLineIteratorPixel dstIt = dst->createHLineIterator(rect.x(), rect.y(), rect.width());
162
155
    for (int i = rect.y(); i < rect.height(); i++) {
173
166
    }
174
167
}
175
168
 
 
169
bool KisMathToolbox::getFromDoubleChannelPtr(QList<KoChannelInfo *> cis, QVector<PtrFromDouble>& f)
 
170
{
 
171
    qint32 channels = cis.count();
 
172
 
 
173
    for (qint32 k = 0; k < channels; k++) {
 
174
        switch (cis[k]->channelValueType()) {
 
175
        case KoChannelInfo::UINT8:
 
176
            f[k] = fromDouble<quint8>;
 
177
            break;
 
178
        case KoChannelInfo::UINT16:
 
179
            f[k] = fromDouble<quint16>;
 
180
            break;
 
181
#ifdef HAVE_OPENEXR
 
182
        case KoChannelInfo::FLOAT16:
 
183
            f[k] = fromDouble<half>;
 
184
            break;
 
185
#endif
 
186
        case KoChannelInfo::FLOAT32:
 
187
            f[k] = fromDouble<float>;
 
188
            break;
 
189
        case KoChannelInfo::INT8:
 
190
            f[k] = fromDouble<qint8>;
 
191
            break;
 
192
        case KoChannelInfo::INT16:
 
193
            f[k] = fromDouble<qint16>;
 
194
            break;
 
195
        default:
 
196
            warnKrita << "Unsupported value type in KisMathToolbox";
 
197
            return false;
 
198
        }
 
199
    }
 
200
 
 
201
    return true;
 
202
}
 
203
 
 
204
double KisMathToolbox::minChannelValue(KoChannelInfo *c)
 
205
{
 
206
    switch (c->channelValueType())
 
207
    {
 
208
    case KoChannelInfo::UINT8 : return KoColorSpaceMathsTraits<quint8>::min;
 
209
    case KoChannelInfo::UINT16 : return KoColorSpaceMathsTraits<quint16>::min;
 
210
    case KoChannelInfo::UINT32 : return KoColorSpaceMathsTraits<quint32>::min;
 
211
    #ifdef HAVE_OPENEXR
 
212
    case KoChannelInfo::FLOAT16 : return KoColorSpaceMathsTraits<half>::min;
 
213
    #endif
 
214
    case KoChannelInfo::FLOAT32 : return KoColorSpaceMathsTraits<float>::min;
 
215
    case KoChannelInfo::FLOAT64 : return KoColorSpaceMathsTraits<double>::min;
 
216
    case KoChannelInfo::INT8 : return 127;
 
217
    case KoChannelInfo::INT16 : return KoColorSpaceMathsTraits<qint16>::min;
 
218
    default: return 0;
 
219
    }
 
220
}
 
221
 
 
222
double KisMathToolbox::maxChannelValue(KoChannelInfo *c)
 
223
{
 
224
    switch (c->channelValueType())
 
225
    {
 
226
    case KoChannelInfo::UINT8 : return KoColorSpaceMathsTraits<quint8>::max;
 
227
    case KoChannelInfo::UINT16 : return KoColorSpaceMathsTraits<quint16>::max;
 
228
    case KoChannelInfo::UINT32 : return KoColorSpaceMathsTraits<quint32>::max;
 
229
    #ifdef HAVE_OPENEXR
 
230
    case KoChannelInfo::FLOAT16 : return KoColorSpaceMathsTraits<half>::max;
 
231
    #endif
 
232
    case KoChannelInfo::FLOAT32 : return KoColorSpaceMathsTraits<float>::max;
 
233
    case KoChannelInfo::FLOAT64 : return KoColorSpaceMathsTraits<double>::max;
 
234
    case KoChannelInfo::INT8 : return -128;
 
235
    case KoChannelInfo::INT16 : return KoColorSpaceMathsTraits<qint16>::max;
 
236
    default: return 0;
 
237
    }
 
238
}
 
239
 
176
240
#include "kis_math_toolbox.moc"