KisMathToolbox Class Reference

#include <kis_math_toolbox.h>

Classes
struct	KisFloatRepresentation

Public Types
typedef KisFloatRepresentation	KisWavelet

Public Member Functions
uint	fastWaveletTotalSteps (const QRect &)
KisWavelet *	fastWaveletTransformation (KisPaintDeviceSP src, const QRect &, KisWavelet *buff=0)
void	fastWaveletUntransformation (KisPaintDeviceSP dst, const QRect &, KisWavelet *wav, KisWavelet *buff=0)
bool	getFromDoubleChannelPtr (QList< KoChannelInfo * > cis, QVector< PtrFromDouble > &f)
bool	getFromDoubleCheckNullChannelPtr (QList< KoChannelInfo * > cis, QVector< PtrFromDoubleCheckNull > &f)
bool	getToDoubleChannelPtr (QList< KoChannelInfo * > cis, QVector< PtrToDouble > &f)
KisWavelet *	initWavelet (KisPaintDeviceSP lay, const QRect &)
double	maxChannelValue (KoChannelInfo *)
double	minChannelValue (KoChannelInfo *)

Private Member Functions
void	transformFromFR (KisPaintDeviceSP dst, KisFloatRepresentation *, const QRect &)
void	transformToFR (KisPaintDeviceSP src, KisFloatRepresentation *, const QRect &)
void	wavetrans (KisWavelet *wav, KisWavelet *buff, uint halfsize)
void	waveuntrans (KisWavelet *wav, KisWavelet *buff, uint halfsize)

Detailed Description

Definition at line 34 of file kis_math_toolbox.h.

Member Typedef Documentation

KisWavelet

typedef KisFloatRepresentation KisMathToolbox::KisWavelet

Definition at line 60 of file kis_math_toolbox.h.

Member Function Documentation

fastWaveletTotalSteps()

uint KisMathToolbox::fastWaveletTotalSteps ( const QRect & rect )

inline

Definition at line 129 of file kis_math_toolbox.h.

{
    int size, steps;
    int maxrectsize = (rect.height() < rect.width()) ? rect.width() : rect.height();
    steps = 0;
    for (size = 2; size < maxrectsize; size *= 2) steps += size / 2; ;
    return steps;
}

fastWaveletTransformation()

KisMathToolbox::KisWavelet * KisMathToolbox::fastWaveletTransformation	(	KisPaintDeviceSP	src,
		const QRect &	rect,
		KisWavelet *	buff = 0 )

This function reconstruct the layer from the information of a wavelet

Parameters

src	layer from which the wavelet will be computed
rect	the rectangular for reconstruction
buff	if set to 0, the buffer will be initialized by the function, you might want to give a buff to the function if you want to use the same buffer in transformToWavelet and in untransformToWavelet, use initWavelet to initialize the buffer

Definition at line 328 of file kis_math_toolbox.cpp.

{
    if (buff == 0) {
        buff = initWavelet(src, rect);
    }
    KisWavelet* wav = initWavelet(src, rect);
    transformToFR(src, wav, rect);
    wavetrans(wav, buff, wav->size / 2);
 
    return wav;
}

References initWavelet(), KisMathToolbox::KisFloatRepresentation::size, transformToFR(), and wavetrans().

fastWaveletUntransformation()

void KisMathToolbox::fastWaveletUntransformation	(	KisPaintDeviceSP	dst,
		const QRect &	rect,
		KisWavelet *	wav,
		KisWavelet *	buff = 0 )

This function reconstruct the layer from the information of a wavelet

Parameters

dst	layer on which the wavelet will be untransform
rect	the rectangular for reconstruction
wav	the wavelet
buff	if set to 0, the buffer will be initialized by the function, you might want to give a buff to the function if you want to use the same buffer in transformToWavelet and in untransformToWavelet, use initWavelet to initialize the buffer

Definition at line 340 of file kis_math_toolbox.cpp.

{
    if (buff == 0) {
        buff = initWavelet(dst, rect);
    }
 
    waveuntrans(wav, buff, 1);
    transformFromFR(dst, wav, rect);
}

References initWavelet(), transformFromFR(), and waveuntrans().

getFromDoubleChannelPtr()

bool KisMathToolbox::getFromDoubleChannelPtr	(	QList< KoChannelInfo * >	cis,
		QVector< PtrFromDouble > &	f )

Definition at line 153 of file kis_math_toolbox.cpp.

{
    qint32 channels = cis.count();
 
    for (qint32 k = 0; k < channels; k++) {
        switch (cis[k]->channelValueType()) {
        case KoChannelInfo::UINT8:
            f[k] = fromDouble<quint8>;
            break;
        case KoChannelInfo::UINT16:
            f[k] = fromDouble<quint16>;
            break;
#ifdef HAVE_OPENEXR
        case KoChannelInfo::FLOAT16:
            f[k] = fromDoubleF<half>;
            break;
#endif
        case KoChannelInfo::FLOAT32:
            f[k] = fromDoubleF<float>;
            break;
        case KoChannelInfo::INT8:
            f[k] = fromDouble<qint8>;
            break;
        case KoChannelInfo::INT16:
            f[k] = fromDouble<qint16>;
            break;
        default:
            warnKrita << "Unsupported value type in KisMathToolbox";
            return false;
        }
    }
 
    return true;
}

References KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::INT16, KoChannelInfo::INT8, KoChannelInfo::UINT16, KoChannelInfo::UINT8, and warnKrita.

getFromDoubleCheckNullChannelPtr()

bool KisMathToolbox::getFromDoubleCheckNullChannelPtr	(	QList< KoChannelInfo * >	cis,
		QVector< PtrFromDoubleCheckNull > &	f )

Definition at line 188 of file kis_math_toolbox.cpp.

{
    qint32 channels = cis.count();
 
    for (qint32 k = 0; k < channels; k++) {
        switch (cis[k]->channelValueType()) {
        case KoChannelInfo::UINT8:
            f[k] = fromDoubleCheckNull<quint8>;
            break;
        case KoChannelInfo::UINT16:
            f[k] = fromDoubleCheckNull<quint16>;
            break;
#ifdef HAVE_OPENEXR
        case KoChannelInfo::FLOAT16:
            f[k] = fromDoubleCheckNullF<half>;
            break;
#endif
        case KoChannelInfo::FLOAT32:
            f[k] = fromDoubleCheckNullF<float>;
            break;
        case KoChannelInfo::INT8:
            f[k] = fromDoubleCheckNull<qint8>;
            break;
        case KoChannelInfo::INT16:
            f[k] = fromDoubleCheckNull<qint16>;
            break;
        default:
            warnKrita << "Unsupported value type in KisMathToolbox";
            return false;
        }
    }
 
    return true;
}

References KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::INT16, KoChannelInfo::INT8, KoChannelInfo::UINT16, KoChannelInfo::UINT8, and warnKrita.

getToDoubleChannelPtr()

bool KisMathToolbox::getToDoubleChannelPtr	(	QList< KoChannelInfo * >	cis,
		QVector< PtrToDouble > &	f )

Definition at line 90 of file kis_math_toolbox.cpp.

{
    qint32 channels = cis.count();
 
    for (qint32 k = 0; k < channels; k++) {
        switch (cis[k]->channelValueType()) {
        case KoChannelInfo::UINT8:
            f[k] = toDouble<quint8>;
            break;
        case KoChannelInfo::UINT16:
            f[k] = toDouble<quint16>;
            break;
#ifdef HAVE_OPENEXR
        case KoChannelInfo::FLOAT16:
            f[k] = toDouble<half>;
            break;
#endif
        case KoChannelInfo::FLOAT32:
            f[k] = toDouble<float>;
            break;
        case KoChannelInfo::INT8:
            f[k] = toDouble<qint8>;
            break;
        case KoChannelInfo::INT16:
            f[k] = toDouble<qint16>;
            break;
        default:
            warnKrita << "Unsupported value type in KisMathToolbox";
            return false;
        }
    }
 
    return true;
}

References KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::INT16, KoChannelInfo::INT8, KoChannelInfo::UINT16, KoChannelInfo::UINT8, and warnKrita.

initWavelet()

KisMathToolbox::KisWavelet * KisMathToolbox::initWavelet ( KisPaintDeviceSP lay, const QRect & rect )

inline

This function initializes a wavelet structure

Parameters

lay	the layer that will be used for the transformation
rect	the rectangular for transformation

Definition at line 120 of file kis_math_toolbox.h.

{
    int size;
    int maxrectsize = (rect.height() < rect.width()) ? rect.width() : rect.height();
    for (size = 2; size < maxrectsize; size *= 2) ;
    qint32 depth = src->colorSpace()->colorChannelCount();
    return new KisWavelet(size, depth);
}

maxChannelValue()

double KisMathToolbox::maxChannelValue

(

KoChannelInfo *

c

)

Definition at line 241 of file kis_math_toolbox.cpp.

{
    switch (c->channelValueType())
    {
    case KoChannelInfo::UINT8 : return KoColorSpaceMathsTraits<quint8>::max;
    case KoChannelInfo::UINT16 : return KoColorSpaceMathsTraits<quint16>::max;
    case KoChannelInfo::UINT32 : return KoColorSpaceMathsTraits<quint32>::max;
    #ifdef HAVE_OPENEXR
    case KoChannelInfo::FLOAT16 : return KoColorSpaceMathsTraits<half>::max;
    #endif
    case KoChannelInfo::FLOAT32 : return KoColorSpaceMathsTraits<float>::max;
    case KoChannelInfo::FLOAT64 : return KoColorSpaceMathsTraits<double>::max;
    case KoChannelInfo::INT8 : return -128;
    case KoChannelInfo::INT16 : return KoColorSpaceMathsTraits<qint16>::max;
    default: return 0;
    }
}

References KoChannelInfo::channelValueType(), KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::FLOAT64, KoChannelInfo::INT16, KoChannelInfo::INT8, KoChannelInfo::UINT16, KoChannelInfo::UINT32, and KoChannelInfo::UINT8.

minChannelValue()

double KisMathToolbox::minChannelValue

(

KoChannelInfo *

c

)

Definition at line 223 of file kis_math_toolbox.cpp.

{
    switch (c->channelValueType())
    {
    case KoChannelInfo::UINT8 : return KoColorSpaceMathsTraits<quint8>::min;
    case KoChannelInfo::UINT16 : return KoColorSpaceMathsTraits<quint16>::min;
    case KoChannelInfo::UINT32 : return KoColorSpaceMathsTraits<quint32>::min;
    #ifdef HAVE_OPENEXR
    case KoChannelInfo::FLOAT16 : return KoColorSpaceMathsTraits<half>::min;
    #endif
    case KoChannelInfo::FLOAT32 : return KoColorSpaceMathsTraits<float>::min;
    case KoChannelInfo::FLOAT64 : return KoColorSpaceMathsTraits<double>::min;
    case KoChannelInfo::INT8 : return 127;
    case KoChannelInfo::INT16 : return KoColorSpaceMathsTraits<qint16>::min;
    default: return 0;
    }
}

References KoChannelInfo::channelValueType(), KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::FLOAT64, KoChannelInfo::INT16, KoChannelInfo::INT8, KoChannelInfo::UINT16, KoChannelInfo::UINT32, and KoChannelInfo::UINT8.

transformFromFR()

void KisMathToolbox::transformFromFR ( KisPaintDeviceSP dst, KisFloatRepresentation * fr, const QRect & rect )

private

This function transform a KisFloatRepresentation into a paint device, this function is colorspace independent, for Wavelet, Pyramid and FFT the data is always the exact value of the channel stored in a float.

Definition at line 125 of file kis_math_toolbox.cpp.

{
    qint32 depth = dst->colorSpace()->colorChannelCount();
    QList<KoChannelInfo *> cis = dst->colorSpace()->channels();
    // remove non-color channels
    for (qint32 c = 0; c < cis.count(); ++c) {
        if (cis[c]->channelType() != KoChannelInfo::COLOR)
            cis.removeAt(c--);
    }
 
    QVector<PtrFromDouble> f(depth);
    if (!getFromDoubleChannelPtr(cis, f))
        return;
 
    KisHLineIteratorSP dstIt = dst->createHLineIteratorNG(rect.x(), rect.y(), rect.width());
    for (int i = rect.y(); i < rect.height(); i++) {
        float *srcIt = fr->coeffs + (i - rect.y()) * fr->size * fr->depth;
        do {
            quint8* v1 = dstIt->rawData();
            for (int k = 0; k < depth; k++) {
                f[k](v1, cis[k]->pos(), *srcIt);
                ++srcIt;
            }
        } while(dstIt->nextPixel());
        dstIt->nextRow();
    }
}

References KoColorSpace::channels, KisMathToolbox::KisFloatRepresentation::coeffs, KoChannelInfo::COLOR, KoColorSpace::colorChannelCount(), KisPaintDevice::colorSpace(), KisPaintDevice::createHLineIteratorNG(), KisMathToolbox::KisFloatRepresentation::depth, getFromDoubleChannelPtr(), and KisMathToolbox::KisFloatRepresentation::size.

transformToFR()

void KisMathToolbox::transformToFR ( KisPaintDeviceSP src, KisFloatRepresentation * fr, const QRect & rect )

private

This function transform a paint device into a KisFloatRepresentation, this function is colorspace independent, for Wavelet, Pyramid and FFT the data is always the exact value of the channel stored in a float.

Definition at line 62 of file kis_math_toolbox.cpp.

{
    qint32 depth = src->colorSpace()->colorChannelCount();
    QList<KoChannelInfo *> cis = src->colorSpace()->channels();
    // remove non-color channels
    for (qint32 c = 0; c < cis.count(); ++c) {
        if (cis[c]->channelType() != KoChannelInfo::COLOR)
            cis.removeAt(c--);
    }
    QVector<PtrToDouble> f(depth);
    if (!getToDoubleChannelPtr(cis, f))
        return;
 
    KisHLineConstIteratorSP srcIt = src->createHLineIteratorNG(rect.x(), rect.y(), rect.width());
 
    for (int i = rect.y(); i < rect.height(); i++) {
        float *dstIt = fr->coeffs + (i - rect.y()) * fr->size * fr->depth;
        do {
            const quint8* v1 = srcIt->oldRawData();
            for (int k = 0; k < depth; k++) {
                *dstIt = f[k](v1, cis[k]->pos());
                ++dstIt;
            }
        } while (srcIt->nextPixel());
        srcIt->nextRow();
    }
}

References KisMathToolbox::KisFloatRepresentation::coeffs, KoChannelInfo::COLOR, KisMathToolbox::KisFloatRepresentation::depth, getToDoubleChannelPtr(), KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KisBaseConstAccessor::oldRawData(), and KisMathToolbox::KisFloatRepresentation::size.

wavetrans()

void KisMathToolbox::wavetrans ( KisMathToolbox::KisWavelet * wav, KisMathToolbox::KisWavelet * buff, uint halfsize )

private

Definition at line 259 of file kis_math_toolbox.cpp.

{
    uint l = (2 * halfsize) * wav->depth * sizeof(float);
    for (uint i = 0; i < halfsize; i++) {
        float * itLL = buff->coeffs + i * buff->size * buff->depth;
        float * itHL = buff->coeffs + (i * buff->size + halfsize) * buff->depth;
        float * itLH = buff->coeffs + (halfsize + i) * buff->size * buff->depth;
        float * itHH = buff->coeffs + ((halfsize + i) * buff->size + halfsize) * buff->depth;
        float * itS11 = wav->coeffs + 2 * i * wav->size * wav->depth;
        float * itS12 = wav->coeffs + (2 * i * wav->size + 1) * wav->depth;
        float * itS21 = wav->coeffs + (2 * i + 1) * wav->size * wav->depth;
        float * itS22 = wav->coeffs + ((2 * i + 1) * wav->size + 1) * wav->depth;
        for (uint j = 0; j < halfsize; j++) {
            for (uint k = 0; k < wav->depth; k++) {
                *(itLL++) = (*itS11 + *itS12 + *itS21 + *itS22) * M_SQRT1_2;
                *(itHL++) = (*itS11 - *itS12 + *itS21 - *itS22) * M_SQRT1_2;
                *(itLH++) = (*itS11 + *itS12 - *itS21 - *itS22) * M_SQRT1_2;
                *(itHH++) = (*(itS11++) - *(itS12++) - *(itS21++) + *(itS22++)) * M_SQRT1_2;
            }
            itS11 += wav->depth; itS12 += wav->depth;
            itS21 += wav->depth; itS22 += wav->depth;
        }
    }
    for (uint i = 0; i < halfsize; i++) {
        uint p = i * wav->size * wav->depth;
        memcpy(wav->coeffs + p, buff->coeffs + p, l);
        p = (i + halfsize) * wav->size * wav->depth;
        memcpy(wav->coeffs + p, buff->coeffs + p, l);
    }
    if (halfsize != 1) {
        wavetrans(wav, buff, halfsize / 2);
    }
}

References KisMathToolbox::KisFloatRepresentation::coeffs, KisMathToolbox::KisFloatRepresentation::depth, p, KisMathToolbox::KisFloatRepresentation::size, and wavetrans().

waveuntrans()

void KisMathToolbox::waveuntrans ( KisMathToolbox::KisWavelet * wav, KisMathToolbox::KisWavelet * buff, uint halfsize )

private

Definition at line 293 of file kis_math_toolbox.cpp.

{
    uint l = (2 * halfsize) * wav->depth * sizeof(float);
    for (uint i = 0; i < halfsize; i++) {
        float * itLL = wav->coeffs + i * buff->size * buff->depth;
        float * itHL = wav->coeffs + (i * buff->size + halfsize) * buff->depth;
        float * itLH = wav->coeffs + (halfsize + i) * buff->size * buff->depth;
        float * itHH = wav->coeffs + ((halfsize + i) * buff->size + halfsize) * buff->depth;
        float * itS11 = buff->coeffs + 2 * i * wav->size * wav->depth;
        float * itS12 = buff->coeffs + (2 * i * wav->size + 1) * wav->depth;
        float * itS21 = buff->coeffs + (2 * i + 1) * wav->size * wav->depth;
        float * itS22 = buff->coeffs + ((2 * i + 1) * wav->size + 1) * wav->depth;
        for (uint j = 0; j < halfsize; j++) {
            for (uint k = 0; k < wav->depth; k++) {
                *(itS11++) = (*itLL + *itHL + *itLH + *itHH) * 0.25 * M_SQRT2;
                *(itS12++) = (*itLL - *itHL + *itLH - *itHH) * 0.25 * M_SQRT2;
                *(itS21++) = (*itLL + *itHL - *itLH - *itHH) * 0.25 * M_SQRT2;
                *(itS22++) = (*(itLL++) - *(itHL++) - *(itLH++) + *(itHH++)) * 0.25 * M_SQRT2;
            }
            itS11 += wav->depth; itS12 += wav->depth;
            itS21 += wav->depth; itS22 += wav->depth;
        }
    }
    for (uint i = 0; i < halfsize; i++) {
        uint p = i * wav->size * wav->depth;
        memcpy(wav->coeffs + p, buff->coeffs + p, l);
        p = (i + halfsize) * wav->size * wav->depth;
        memcpy(wav->coeffs + p, buff->coeffs + p, l);
    }
 
    if (halfsize != wav->size / 2) {
        waveuntrans(wav, buff, halfsize*2);
    }
}

References KisMathToolbox::KisFloatRepresentation::coeffs, KisMathToolbox::KisFloatRepresentation::depth, p, KisMathToolbox::KisFloatRepresentation::size, and waveuntrans().

---

The documentation for this class was generated from the following files:

• libs/image/kis_math_toolbox.h
• libs/image/kis_math_toolbox.cpp