KisGaussianKernel Class Reference

#include <kis_gaussian_kernel.h>

Static Public Member Functions
static void	applyDilate (KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction=false)
static void	applyErodeU8 (KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction=false)
static void	applyGaussian (KisPaintDeviceSP device, const QRect &rect, qreal xRadius, qreal yRadius, const QBitArray &channelFlags, KoUpdater *updater, bool createTransaction=false, KisConvolutionBorderOp borderOp=BORDER_REPEAT)
static void	applyLoG (KisPaintDeviceSP device, const QRect &rect, qreal radius, qreal coeff, const QBitArray &channelFlags, KoUpdater *progressUpdater)
static void	applyTightLoG (KisPaintDeviceSP device, const QRect &rect, qreal radius, qreal coeff, const QBitArray &channelFlags, KoUpdater *progressUpdater)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createDilateMatrix (qreal radius)
static KisConvolutionKernelSP	createHorizontalKernel (qreal radius)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createHorizontalMatrix (qreal radius)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createLoGMatrix (qreal radius, qreal coeff, bool zeroCentered, bool includeWrappedArea)
static KisConvolutionKernelSP	createUniform2DKernel (qreal xRadius, qreal yRadius)
static KisConvolutionKernelSP	createVerticalKernel (qreal radius)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createVerticalMatrix (qreal radius)
static int	kernelSizeFromRadius (qreal radius)
static qreal	sigmaFromRadius (qreal radius)

Detailed Description

Definition at line 18 of file kis_gaussian_kernel.h.

Member Function Documentation

applyDilate()

void KisGaussianKernel::applyDilate ( KisPaintDeviceSP device, const QRect & rect, qreal radius, const QBitArray & channelFlags, KoUpdater * progressUpdater, bool createTransaction = false )

static

Definition at line 344 of file kis_gaussian_kernel.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
 
    QPoint srcTopLeft = rect.topLeft();
 
    KisConvolutionPainter painter(device);
    painter.setChannelFlags(channelFlags);
    painter.setProgress(progressUpdater);
 
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createDilateMatrix(radius);
    KisConvolutionKernelSP kernel =
        KisConvolutionKernel::fromMatrix(matrix,
                                         0,
                                         1.0);
 
    QScopedPointer<KisTransaction> transaction;
    if (createTransaction && painter.needsTransaction(kernel)) {
        transaction.reset(new KisTransaction(device));
    }
 
    painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}

References KisConvolutionPainter::applyMatrix(), BORDER_REPEAT, KisPaintDevice::colorSpace(), createDilateMatrix(), KisConvolutionKernel::fromMatrix(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisConvolutionPainter::needsTransaction(), KoColorSpace::pixelSize(), KisPainter::setChannelFlags(), and KisPainter::setProgress().

applyErodeU8()

void KisGaussianKernel::applyErodeU8 ( KisPaintDeviceSP device, const QRect & rect, qreal radius, const QBitArray & channelFlags, KoUpdater * progressUpdater, bool createTransaction = false )

static

Definition at line 370 of file kis_gaussian_kernel.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
 
    {
        KisSequentialIterator dstIt(device, rect);
        while (dstIt.nextPixel()) {
            quint8 *dstPtr = dstIt.rawData();
            *dstPtr = 255 - *dstPtr;
        }
    }
 
    applyDilate(device, rect, radius, channelFlags, progressUpdater, createTransaction);
 
    {
        KisSequentialIterator dstIt(device, rect);
        while (dstIt.nextPixel()) {
            quint8 *dstPtr = dstIt.rawData();
            *dstPtr = 255 - *dstPtr;
        }
    }
}

References applyDilate(), KisPaintDevice::colorSpace(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::pixelSize(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

applyGaussian()

void KisGaussianKernel::applyGaussian ( KisPaintDeviceSP device, const QRect & rect, qreal xRadius, qreal yRadius, const QBitArray & channelFlags, KoUpdater * updater, bool createTransaction = false, KisConvolutionBorderOp borderOp = BORDER_REPEAT )

static

Definition at line 102 of file kis_gaussian_kernel.cpp.

{
    QPoint srcTopLeft = rect.topLeft();
 
 
    if (KisConvolutionPainter::supportsFFTW()) {
        KisConvolutionPainter painter(device, KisConvolutionPainter::FFTW);
        painter.setChannelFlags(channelFlags);
        painter.setProgress(progressUpdater);
 
        KisConvolutionKernelSP kernel2D = KisGaussianKernel::createUniform2DKernel(xRadius, yRadius);
 
        QScopedPointer<KisTransaction> transaction;
        if (createTransaction && painter.needsTransaction(kernel2D)) {
            transaction.reset(new KisTransaction(device));
        }
 
        painter.applyMatrix(kernel2D, device, srcTopLeft, srcTopLeft, rect.size(), borderOp);
 
    } else if (xRadius > 0.0 && yRadius > 0.0) {
        KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
        interm->prepareClone(device);
 
        KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
        KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
 
        qreal verticalCenter = qreal(kernelVertical->height()) / 2.0;
 
        KisConvolutionPainter horizPainter(interm);
        horizPainter.setChannelFlags(channelFlags);
        horizPainter.setProgress(progressUpdater);
        horizPainter.applyMatrix(kernelHoriz, device,
                                 srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                 srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                 rect.size() + QSize(0, 2 * ceil(verticalCenter)), borderOp);
 
 
        KisConvolutionPainter verticalPainter(device);
        verticalPainter.setChannelFlags(channelFlags);
        verticalPainter.setProgress(progressUpdater);
        verticalPainter.applyMatrix(kernelVertical, interm, srcTopLeft, srcTopLeft, rect.size(), borderOp);
 
    } else if (xRadius > 0.0) {
        KisConvolutionPainter painter(device);
        painter.setChannelFlags(channelFlags);
        painter.setProgress(progressUpdater);
 
        KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
 
        QScopedPointer<KisTransaction> transaction;
        if (createTransaction && painter.needsTransaction(kernelHoriz)) {
            transaction.reset(new KisTransaction(device));
        }
 
        painter.applyMatrix(kernelHoriz, device, srcTopLeft, srcTopLeft, rect.size(), borderOp);
 
    } else if (yRadius > 0.0) {
        KisConvolutionPainter painter(device);
        painter.setChannelFlags(channelFlags);
        painter.setProgress(progressUpdater);
 
        KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
 
        QScopedPointer<KisTransaction> transaction;
        if (createTransaction && painter.needsTransaction(kernelVertical)) {
            transaction.reset(new KisTransaction(device));
        }
 
        painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), borderOp);
    }
}

References KisConvolutionPainter::applyMatrix(), KisPaintDevice::colorSpace(), createHorizontalKernel(), createUniform2DKernel(), createVerticalKernel(), KisConvolutionPainter::FFTW, KisConvolutionKernel::height(), KisConvolutionPainter::needsTransaction(), KisPaintDevice::prepareClone(), KisPainter::setChannelFlags(), KisPainter::setProgress(), and KisConvolutionPainter::supportsFFTW().

applyLoG()

void KisGaussianKernel::applyLoG ( KisPaintDeviceSP device, const QRect & rect, qreal radius, qreal coeff, const QBitArray & channelFlags, KoUpdater * progressUpdater )

static

Definition at line 264 of file kis_gaussian_kernel.cpp.

{
    QPoint srcTopLeft = rect.topLeft();
 
    KisConvolutionPainter painter(device);
    painter.setChannelFlags(channelFlags);
    painter.setProgress(progressUpdater);
 
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix =
        createLoGMatrix(radius, coeff, false, true);
    KisConvolutionKernelSP kernel =
        KisConvolutionKernel::fromMatrix(matrix,
                                         0,
                                         0);
 
    painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}

References KisConvolutionPainter::applyMatrix(), BORDER_REPEAT, createLoGMatrix(), KisConvolutionKernel::fromMatrix(), KisPainter::setChannelFlags(), and KisPainter::setProgress().

applyTightLoG()

void KisGaussianKernel::applyTightLoG ( KisPaintDeviceSP device, const QRect & rect, qreal radius, qreal coeff, const QBitArray & channelFlags, KoUpdater * progressUpdater )

static

Definition at line 286 of file kis_gaussian_kernel.cpp.

{
    QPoint srcTopLeft = rect.topLeft();
 
    KisConvolutionPainter painter(device);
    painter.setChannelFlags(channelFlags);
    painter.setProgress(progressUpdater);
 
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix =
        createLoGMatrix(radius, coeff, true, false);
    KisConvolutionKernelSP kernel =
        KisConvolutionKernel::fromMatrix(matrix,
                                         0,
                                         0);
 
    painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}

References KisConvolutionPainter::applyMatrix(), BORDER_REPEAT, createLoGMatrix(), KisConvolutionKernel::fromMatrix(), KisPainter::setChannelFlags(), and KisPainter::setProgress().

createDilateMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisGaussianKernel::createDilateMatrix ( qreal radius )

static

The kernel size should always be odd, then the position of the central pixel can be easily calculated

Definition at line 308 of file kis_gaussian_kernel.cpp.

{
    const int kernelSize = 2 * std::ceil(radius) + 1;
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
    const qreal fadeStart = qMax(1.0, radius - 1.0);
 
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    for (int y = 0; y < kernelSize; y++) {
        const qreal yDistance = center - y;
        for (int x = 0; x < kernelSize; x++) {
            const qreal xDistance = center - x;
 
            const qreal distance = std::sqrt(pow2(xDistance) + pow2(yDistance));
 
            qreal value = 1.0;
 
            if (distance > radius + 1e-3) {
                value = 0.0;
            } else if (distance > fadeStart) {
                value = qMax(0.0, radius - distance);
            }
 
            matrix(x, y) = value;
        }
    }
 
    return matrix;
}

References distance(), KIS_ASSERT_RECOVER_NOOP, pow2(), and value().

createHorizontalKernel()

KisConvolutionKernelSP KisGaussianKernel::createHorizontalKernel ( qreal radius )

static

Definition at line 78 of file kis_gaussian_kernel.cpp.

{
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createHorizontalMatrix(radius);
    return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
}

References createHorizontalMatrix(), and KisConvolutionKernel::fromMatrix().

createHorizontalMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisGaussianKernel::createHorizontalMatrix ( qreal radius )

static

The kernel size should always be odd, then the position of the central pixel can be easily calculated

Definition at line 28 of file kis_gaussian_kernel.cpp.

{
    int kernelSize = kernelSizeFromRadius(radius);
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(1, kernelSize);
 
    const qreal sigma = sigmaFromRadius(radius);
    const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
    const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    for (int x = 0; x < kernelSize; x++) {
        qreal xDistance = center - x;
        matrix(0, x) = multiplicand * exp( -xDistance * xDistance * exponentMultiplicand );
    }
 
    return matrix;
}

References kernelSizeFromRadius(), KIS_ASSERT_RECOVER_NOOP, M_PI, and sigmaFromRadius().

createLoGMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisGaussianKernel::createLoGMatrix ( qreal radius, qreal coeff, bool zeroCentered, bool includeWrappedArea )

static

The kernel size should always be odd, then the position of the central pixel can be easily calculated

Definition at line 181 of file kis_gaussian_kernel.cpp.

{
    int kernelSize = 2 * (includeWrappedArea ? 2 : 1) * std::ceil(radius) + 1;
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
    const qreal sigma = radius/* / sqrt(2)*/;
    const qreal multiplicand = -1.0 / (M_PI * pow2(pow2(sigma)));
    const qreal exponentMultiplicand = 1 / (2 * pow2(sigma));
 
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    for (int y = 0; y < kernelSize; y++) {
        const qreal yDistance = center - y;
        for (int x = 0; x < kernelSize; x++) {
            const qreal xDistance = center - x;
            const qreal distance = pow2(xDistance) + pow2(yDistance);
            const qreal normalizedDistance = exponentMultiplicand * distance;
 
            matrix(x, y) = multiplicand *
                (1.0 - normalizedDistance) *
                exp(-normalizedDistance);
        }
    }
 
    qreal lateral = matrix.sum() - matrix(center, center);
    matrix(center, center) = -lateral;
 
    qreal totalSum = 0;
 
    if (zeroCentered) {
        for (int y = 0; y < kernelSize; y++) {
            for (int x = 0; x < kernelSize; x++) {
                const qreal value = matrix(x, y);
                totalSum += value;
            }
        }
    }
 
    qreal positiveSum = 0;
    qreal sideSum = 0;
    qreal quarterSum = 0;
    totalSum = 0;
 
    const qreal offset = totalSum / pow2(qreal(kernelSize));
 
    for (int y = 0; y < kernelSize; y++) {
        for (int x = 0; x < kernelSize; x++) {
            qreal value = matrix(x, y);
            value -= offset;
            matrix(x, y) = value;
 
            if (value > 0) {
                positiveSum += value;
            }
            if (x > center) {
                sideSum += value;
            }
            if (x > center && y > center) {
                quarterSum += value;
            }
            totalSum += value;
        }
    }
 
 
    const qreal scale = coeff * 2.0 / positiveSum;
    matrix *= scale;
    positiveSum *= scale;
    sideSum *= scale;
    quarterSum *= scale;
 
    //qDebug() << ppVar(positiveSum) << ppVar(sideSum) << ppVar(quarterSum);
    Q_UNUSED(sideSum);
    Q_UNUSED(quarterSum);
 
    return matrix;
}

References distance(), KIS_ASSERT_RECOVER_NOOP, M_PI, pow2(), and value().

createUniform2DKernel()

KisConvolutionKernelSP KisGaussianKernel::createUniform2DKernel ( qreal xRadius, qreal yRadius )

static

Definition at line 92 of file kis_gaussian_kernel.cpp.

{
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> h = createHorizontalMatrix(xRadius);
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> v = createVerticalMatrix(yRadius);
 
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> uni = v * h;
    return KisConvolutionKernel::fromMatrix(uni, 0, uni.sum());
}

References createHorizontalMatrix(), createVerticalMatrix(), KisConvolutionKernel::fromMatrix(), and v.

createVerticalKernel()

KisConvolutionKernelSP KisGaussianKernel::createVerticalKernel ( qreal radius )

static

Definition at line 85 of file kis_gaussian_kernel.cpp.

{
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createVerticalMatrix(radius);
    return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
}

References createVerticalMatrix(), and KisConvolutionKernel::fromMatrix().

createVerticalMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisGaussianKernel::createVerticalMatrix ( qreal radius )

static

The kernel size should always be odd, then the position of the central pixel can be easily calculated

Definition at line 53 of file kis_gaussian_kernel.cpp.

{
    int kernelSize = kernelSizeFromRadius(radius);
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, 1);
 
    const qreal sigma = sigmaFromRadius(radius);
    const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
    const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    for (int y = 0; y < kernelSize; y++) {
        qreal yDistance = center - y;
        matrix(y, 0) = multiplicand * exp( -yDistance * yDistance * exponentMultiplicand );
    }
 
    return matrix;
}

References kernelSizeFromRadius(), KIS_ASSERT_RECOVER_NOOP, M_PI, and sigmaFromRadius().

kernelSizeFromRadius()

int KisGaussianKernel::kernelSizeFromRadius ( qreal radius )

static

Definition at line 21 of file kis_gaussian_kernel.cpp.

{
    return 6 * ceil(sigmaFromRadius(radius)) + 1;
}

References sigmaFromRadius().

sigmaFromRadius()

qreal KisGaussianKernel::sigmaFromRadius ( qreal radius )

static

Definition at line 16 of file kis_gaussian_kernel.cpp.

{
    return 0.3 * radius + 0.3;
}

---

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

• libs/image/kis_gaussian_kernel.h
• libs/image/kis_gaussian_kernel.cpp