KisEdgeDetectionKernel Class Reference

#include <kis_edge_detection_kernel.h>

Public Types
enum	FilterOutput {   pythagorean , xGrowth , xFall , yGrowth ,   yFall , radian }
enum	FilterType { Simple , Prewitt , SobelVector }

Public Member Functions
	KisEdgeDetectionKernel ()

Static Public Member Functions
static void	applyEdgeDetection (KisPaintDeviceSP device, const QRect &rect, qreal xRadius, qreal yRadius, FilterType type, const QBitArray &channelFlags, KoUpdater *progressUpdater, FilterOutput output=pythagorean, bool writeToAlpha=false)
	applyEdgeDetection This applies the edge detection filter to the device.
static void	convertToNormalMap (KisPaintDeviceSP device, const QRect &rect, qreal xRadius, qreal yRadius, FilterType type, int channelToConvert, QVector< int > channelOrder, QVector< bool > channelFlip, const QBitArray &channelFlags, KoUpdater *progressUpdater, boost::optional< bool > useFftw=boost::none)
	convertToNormalMap Convert a channel of the device to a normal map. The channel will be interpreted as a heightmap.
static KisConvolutionKernelSP	createHorizontalKernel (qreal radius, FilterType type, bool denormalize=true, bool reverse=false)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createHorizontalMatrix (qreal radius, FilterType type, bool reverse=false)
	createHorizontalMatrix
static KisConvolutionKernelSP	createVerticalKernel (qreal radius, FilterType type, bool denormalize=true, bool reverse=false)
static Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic >	createVerticalMatrix (qreal radius, FilterType type, bool reverse=false)
	createVerticalMatrix
static int	kernelSizeFromRadius (qreal radius)
static qreal	sigmaFromRadius (qreal radius)

Detailed Description

Definition at line 18 of file kis_edge_detection_kernel.h.

Member Enumeration Documentation

FilterOutput

enum KisEdgeDetectionKernel::FilterOutput

Enumerator
pythagorean
xGrowth
xFall
yGrowth
yFall
radian

Definition at line 29 of file kis_edge_detection_kernel.h.

                      {
        pythagorean,
        xGrowth,
        xFall,
        yGrowth,
        yFall,
        radian
    };

FilterType

enum KisEdgeDetectionKernel::FilterType

Enumerator
Simple
Prewitt
SobelVector

Definition at line 23 of file kis_edge_detection_kernel.h.

                    {
        Simple, //A weird simple method used in our old sobel filter
        Prewitt, //The simpler prewitt detection, which doesn't smooth.
        SobelVector //Sobel does smooth. The creation of bigger kernels is based on an approach regarding vectors.
    };

Constructor & Destructor Documentation

KisEdgeDetectionKernel()

KisEdgeDetectionKernel::KisEdgeDetectionKernel

(

)

Definition at line 17 of file kis_edge_detection_kernel.cpp.

{
 
}

Member Function Documentation

applyEdgeDetection()

void KisEdgeDetectionKernel::applyEdgeDetection ( KisPaintDeviceSP device, const QRect & rect, qreal xRadius, qreal yRadius, KisEdgeDetectionKernel::FilterType type, const QBitArray & channelFlags, KoUpdater * progressUpdater, FilterOutput output = pythagorean, bool writeToAlpha = false )

static

applyEdgeDetection This applies the edge detection filter to the device.

Parameters

device	the device to apply to.
rect	the affected rect.
xRadius	the radius of the horizontal sampling, radius of 0 is effectively disabling it.
yRadius	the radius of the vertical sampling, radius of 0 is effectively disabling it.
type	the type can be prewitt, sobel or simple, each of which have a different sampling for the eventual edge detection.
channelFlags	the affected channels.
progressUpdater	the progress updater if it exists.
output	the output mode.
writeToAlpha	whether or not to have the result applied to the transparency than the color channels, this is useful for fringe effects.

Definition at line 182 of file kis_edge_detection_kernel.cpp.

{
    QPoint srcTopLeft = rect.topLeft();
    KisPainter finalPainter(device);
    finalPainter.setChannelFlags(channelFlags);
    finalPainter.setProgress(progressUpdater);
    if (output == pythagorean || output == radian) {
        KisPaintDeviceSP x_denormalised = new KisPaintDevice(device->colorSpace());
        KisPaintDeviceSP y_denormalised = new KisPaintDevice(device->colorSpace());
 
        x_denormalised->prepareClone(device);
        y_denormalised->prepareClone(device);
 
 
        KisConvolutionKernelSP kernelHorizLeftRight = KisEdgeDetectionKernel::createHorizontalKernel(xRadius, type);
        KisConvolutionKernelSP kernelVerticalTopBottom = KisEdgeDetectionKernel::createVerticalKernel(yRadius, type);
 
        KisConvolutionPainter horizPainterLR(x_denormalised);
        horizPainterLR.setChannelFlags(channelFlags);
        horizPainterLR.setProgress(progressUpdater);
        horizPainterLR.applyMatrix(kernelHorizLeftRight, device,
                                   srcTopLeft,
                                   srcTopLeft,
                                   rect.size(), BORDER_REPEAT);
 
 
        KisConvolutionPainter verticalPainterTB(y_denormalised);
        verticalPainterTB.setChannelFlags(channelFlags);
        verticalPainterTB.setProgress(progressUpdater);
        verticalPainterTB.applyMatrix(kernelVerticalTopBottom, device,
                                      srcTopLeft,
                                      srcTopLeft,
                                      rect.size(), BORDER_REPEAT);
 
        KisSequentialIterator yIterator(y_denormalised, rect);
        KisSequentialIterator xIterator(x_denormalised, rect);
        KisSequentialIterator finalIt(device, rect);
        const int pixelSize = device->colorSpace()->pixelSize();
        const int channels = device->colorSpace()->channelCount();
        const int alphaPos = device->colorSpace()->alphaPos();
        KIS_SAFE_ASSERT_RECOVER_RETURN(alphaPos >= 0);
 
        QVector<float> yNormalised(channels);
        QVector<float> xNormalised(channels);
        QVector<float> finalNorm(channels);
 
        while(yIterator.nextPixel() && xIterator.nextPixel() && finalIt.nextPixel()) {
            device->colorSpace()->normalisedChannelsValue(yIterator.rawData(), yNormalised);
            device->colorSpace()->normalisedChannelsValue(xIterator.rawData(), xNormalised);
            device->colorSpace()->normalisedChannelsValue(finalIt.rawData(), finalNorm);
 
            if (output == pythagorean) {
                for (int c = 0; c<channels; c++) {
                    finalNorm[c] = 2 * sqrt( ((xNormalised[c]-0.5)*(xNormalised[c]-0.5)) + ((yNormalised[c]-0.5)*(yNormalised[c]-0.5)));
                }
            } else { //radian
                for (int c = 0; c<channels; c++) {
                    finalNorm[c] = atan2(xNormalised[c]-0.5, yNormalised[c]-0.5);
                }
            }
 
            if (writeToAlpha) {
                KoColor col(finalIt.rawData(), device->colorSpace());
                qreal alpha = 0;
 
                for (int c = 0; c<(channels-1); c++) {
                    alpha = alpha+finalNorm[c];
                }
 
                alpha = qMin(alpha/(channels-1), col.opacityF());
                col.setOpacity(alpha);
                memcpy(finalIt.rawData(), col.data(), pixelSize);
            } else {
                quint8* f = finalIt.rawData();
                finalNorm[alphaPos] = 1.0;
                device->colorSpace()->fromNormalisedChannelsValue(f, finalNorm);
                memcpy(finalIt.rawData(), f, pixelSize);
            }
 
        }
    } else {
        KisConvolutionKernelSP kernel;
        bool denormalize = !writeToAlpha;
        if (output == xGrowth) {
            kernel = KisEdgeDetectionKernel::createHorizontalKernel(xRadius, type, denormalize);
        } else if (output == xFall) {
            kernel = KisEdgeDetectionKernel::createHorizontalKernel(xRadius, type, denormalize, true);
        } else if (output == yGrowth) {
            kernel = KisEdgeDetectionKernel::createVerticalKernel(yRadius, type, denormalize);
        } else { //yFall
            kernel = KisEdgeDetectionKernel::createVerticalKernel(yRadius, type, denormalize, true);
        }
 
        if (writeToAlpha) {
            KisPaintDeviceSP denormalised = new KisPaintDevice(device->colorSpace());
            denormalised->prepareClone(device);
 
            KisConvolutionPainter kernelP(denormalised);
            kernelP.setChannelFlags(channelFlags);
            kernelP.setProgress(progressUpdater);
            kernelP.applyMatrix(kernel, device,
                                srcTopLeft, srcTopLeft,
                                rect.size(), BORDER_REPEAT);
            KisSequentialIterator iterator(denormalised, rect);
            KisSequentialIterator finalIt(device, rect);
            const int pixelSize = device->colorSpace()->pixelSize();
            const int channels = device->colorSpace()->colorChannelCount();
            QVector<float> normalised(channels);
            while (iterator.nextPixel() && finalIt.nextPixel()) {
                device->colorSpace()->normalisedChannelsValue(iterator.rawData(), normalised);
                KoColor col(finalIt.rawData(), device->colorSpace());
                qreal alpha = 0;
                for (int c = 0; c<channels; c++) {
                    alpha = alpha+normalised[c];
                }
                alpha = qMin(alpha/channels, col.opacityF());
                col.setOpacity(alpha);
                memcpy(finalIt.rawData(), col.data(), pixelSize);
 
            }
 
        } else {
            KisConvolutionPainter kernelP(device);
            kernelP.setChannelFlags(channelFlags);
            kernelP.setProgress(progressUpdater);
            kernelP.applyMatrix(kernel, device,
                                srcTopLeft, srcTopLeft,
                                rect.size(), BORDER_REPEAT);
 
            KisSequentialIterator finalIt(device, rect);
            int numConseqPixels = finalIt.nConseqPixels();
            while (finalIt.nextPixels(numConseqPixels)) {
                numConseqPixels = finalIt.nConseqPixels();
                device->colorSpace()->setOpacity(finalIt.rawData(), 1.0, numConseqPixels);
            }
        }
    }
}

References KoColorSpace::alphaPos(), KisConvolutionPainter::applyMatrix(), BORDER_REPEAT, KoColorSpace::channelCount(), KoColorSpace::colorChannelCount(), KisPaintDevice::colorSpace(), createHorizontalKernel(), createVerticalKernel(), KoColor::data(), KoColorSpace::fromNormalisedChannelsValue(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), KoColorSpace::normalisedChannelsValue(), KoColor::opacityF(), KoColorSpace::pixelSize(), KisPaintDevice::prepareClone(), pythagorean, radian, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisPainter::setChannelFlags(), KoColorSpace::setOpacity(), KoColor::setOpacity(), KisPainter::setProgress(), xFall, xGrowth, and yGrowth.

convertToNormalMap()

void KisEdgeDetectionKernel::convertToNormalMap ( KisPaintDeviceSP device, const QRect & rect, qreal xRadius, qreal yRadius, KisEdgeDetectionKernel::FilterType type, int channelToConvert, QVector< int > channelOrder, QVector< bool > channelFlip, const QBitArray & channelFlags, KoUpdater * progressUpdater, boost::optional< bool > useFftw = boost::none )

static

convertToNormalMap Convert a channel of the device to a normal map. The channel will be interpreted as a heightmap.

Parameters

device	the device
rect	the rectangle to apply this to.
xRadius	the xradius
yRadius	the yradius
type	the edge detection filter.
channelToConvert	the channel to use as a grayscale.
channelOrder	the order in which the xyz coordinates ought to be written to the pixels.
channelFlip	whether to flip the channels
channelFlags	the channel flags
progressUpdater

Definition at line 329 of file kis_edge_detection_kernel.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(device->colorSpace()->channelCount() > 3);
 
    QPoint srcTopLeft = rect.topLeft();
    KisPainter finalPainter(device);
    finalPainter.setChannelFlags(channelFlags);
    finalPainter.setProgress(progressUpdater);
    KisPaintDeviceSP x_denormalised = new KisPaintDevice(device->colorSpace());
    KisPaintDeviceSP y_denormalised = new KisPaintDevice(device->colorSpace());
    x_denormalised->prepareClone(device);
    y_denormalised->prepareClone(device);
 
    KisConvolutionKernelSP kernelHorizLeftRight = KisEdgeDetectionKernel::createHorizontalKernel(yRadius, type, true, !channelFlip[1]);
    KisConvolutionKernelSP kernelVerticalTopBottom = KisEdgeDetectionKernel::createVerticalKernel(xRadius, type, true, !channelFlip[0]);
 
    KisConvolutionPainter horizPainterLR(y_denormalised);
 
    if (useFftw) {
        horizPainterLR.setEnginePreference(*useFftw ? KisConvolutionPainter::FFTW : KisConvolutionPainter::SPATIAL);
    }
 
    horizPainterLR.setChannelFlags(channelFlags);
    horizPainterLR.setProgress(progressUpdater);
    horizPainterLR.applyMatrix(kernelHorizLeftRight, device,
                               srcTopLeft, srcTopLeft,
                               rect.size(), BORDER_REPEAT);
 
 
    KisConvolutionPainter verticalPainterTB(x_denormalised);
 
    if (useFftw) {
        verticalPainterTB.setEnginePreference(*useFftw ? KisConvolutionPainter::FFTW : KisConvolutionPainter::SPATIAL);
    }
 
    verticalPainterTB.setChannelFlags(channelFlags);
    verticalPainterTB.setProgress(progressUpdater);
    verticalPainterTB.applyMatrix(kernelVerticalTopBottom, device,
                                  srcTopLeft,
                                  srcTopLeft,
                                  rect.size(), BORDER_REPEAT);
 
    KisSequentialIterator yIterator(y_denormalised, rect);
    KisSequentialIterator xIterator(x_denormalised, rect);
    KisSequentialIterator finalIt(device, rect);
    const int pixelSize = device->colorSpace()->pixelSize();
    const int channels = device->colorSpace()->channelCount();
    const int alphaPos = device->colorSpace()->alphaPos();
    KIS_SAFE_ASSERT_RECOVER_RETURN(alphaPos >= 0);
 
    QVector<float> yNormalised(channels);
    QVector<float> xNormalised(channels);
    QVector<float> finalNorm(channels);
 
    const QList<KoChannelInfo *> channelInfo = device->colorSpace()->channels();
 
    while(yIterator.nextPixel() && xIterator.nextPixel() && finalIt.nextPixel()) {
        device->colorSpace()->normalisedChannelsValue(yIterator.rawData(), yNormalised);
        device->colorSpace()->normalisedChannelsValue(xIterator.rawData(), xNormalised);
 
        qreal z = 1.0;
        if (channelFlip[2]==true){
            z=-1.0;
        }
        QVector3D normal = QVector3D((xNormalised[channelToConvert]-0.5)*2, (yNormalised[channelToConvert]-0.5)*2, z);
        normal.normalize();
        finalNorm.fill(1.0);
        for (int c = 0; c < 3; c++) {
            finalNorm[channelInfo.at(channelOrder[c])->displayPosition()] = (normal[channelOrder[c]]/2)+0.5;
        }
 
        finalNorm[alphaPos]= 1.0;
 
        quint8* pixel = finalIt.rawData();
        device->colorSpace()->fromNormalisedChannelsValue(pixel, finalNorm);
        memcpy(finalIt.rawData(), pixel, pixelSize);
 
    }
}

References KoColorSpace::alphaPos(), KisConvolutionPainter::applyMatrix(), BORDER_REPEAT, KoColorSpace::channelCount(), KoColorSpace::channels, KisPaintDevice::colorSpace(), createHorizontalKernel(), createVerticalKernel(), KisConvolutionPainter::FFTW, KoColorSpace::fromNormalisedChannelsValue(), KIS_ASSERT_RECOVER_RETURN, KIS_SAFE_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::normalisedChannelsValue(), KoColorSpace::pixelSize(), KisPaintDevice::prepareClone(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisPainter::setChannelFlags(), KisConvolutionPainter::setEnginePreference(), KisPainter::setProgress(), and KisConvolutionPainter::SPATIAL.

createHorizontalKernel()

KisConvolutionKernelSP KisEdgeDetectionKernel::createHorizontalKernel ( qreal radius, KisEdgeDetectionKernel::FilterType type, bool denormalize = true, bool reverse = false )

static

Definition at line 146 of file kis_edge_detection_kernel.cpp.

{
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createHorizontalMatrix(radius, type, reverse);
    if (denormalize) {
        return KisConvolutionKernel::fromMatrix(matrix, 0.5, 1);
    } else {
        return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
    }
}

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

createHorizontalMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisEdgeDetectionKernel::createHorizontalMatrix ( qreal radius, FilterType type, bool reverse = false )

static

createHorizontalMatrix

Parameters

radius	the radius. 1 makes a 3x3 kernel.
type	One of the entries in the enum Filtertype
reverse	which direction the gradient goes. The horizontal gradient by default detects the rightmost edges. Reversed it selects the leftmost edges.

Returns

Definition at line 28 of file kis_edge_detection_kernel.cpp.

{
    int kernelSize = kernelSizeFromRadius(radius);
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    if (type==Prewitt) {
        for (int x = 0; x < kernelSize; x++) {
            for (int y=0; y<kernelSize; y++) {
                qreal xDistance;
                if (reverse) {
                    xDistance = x - center;
                } else {
                    xDistance = center - x;
                }
                matrix(x, y) = xDistance;
            }
        }
    } else if(type==Simple) {
        matrix.resize(kernelSize, 1);
        for (int x = 0; x < kernelSize; x++) {
            qreal xDistance;
            if (reverse) {
                xDistance = x - center;
            } else {
                xDistance = center - x;
            }
            if (x==center) {
                matrix(x, 0) = 0;
            } else {
                matrix(x, 0) = (1/xDistance);
            }
        }
    } else {
        for (int x = 0; x < kernelSize; x++) {
            for (int y=0; y<kernelSize; y++) {
                if (x==center && y==center) {
                    matrix(x, y) = 0;
                } else {
                    qreal xD, yD;
                    if (reverse) {
                        xD = x - center;
                        yD = y - center;
                    } else {
                        xD = center - x;
                        yD = center - y;
                    }
                    matrix(x, y) = xD / (xD*xD + yD*yD);
                }
            }
        }
    }
    return matrix;
}

References kernelSizeFromRadius(), KIS_ASSERT_RECOVER_NOOP, Prewitt, and Simple.

createVerticalKernel()

KisConvolutionKernelSP KisEdgeDetectionKernel::createVerticalKernel ( qreal radius, KisEdgeDetectionKernel::FilterType type, bool denormalize = true, bool reverse = false )

static

Definition at line 159 of file kis_edge_detection_kernel.cpp.

{
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createVerticalMatrix(radius, type, reverse);
    if (denormalize) {
        return KisConvolutionKernel::fromMatrix(matrix, 0.5, 1);
    } else {
        return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
    }
}

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

createVerticalMatrix()

Eigen::Matrix< qreal, Eigen::Dynamic, Eigen::Dynamic > KisEdgeDetectionKernel::createVerticalMatrix ( qreal radius, FilterType type, bool reverse = false )

static

createVerticalMatrix

Parameters

radius	the radius. 1 makes a 3x3 kernel.
type	One of the entries in the enum Filtertype
reverse	which direction the gradient goes. The vertical gradient by default detects the topmost edges. Reversed it selects the bottommost edges.

Returns

Definition at line 87 of file kis_edge_detection_kernel.cpp.

{
    int kernelSize = kernelSizeFromRadius(radius);
 
    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
    KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
    const int center = kernelSize / 2;
 
    if (type==Prewitt) {
        for (int y = 0; y < kernelSize; y++) {
            for (int x=0; x<kernelSize; x++) {
                qreal yDistance;
                if (reverse) {
                    yDistance = y - center;
                } else {
                    yDistance = center - y;
                }
                matrix(x, y) = yDistance;
            }
        }
    } else if(type==Simple) {
        matrix.resize(1, kernelSize);
        for (int y = 0; y < kernelSize; y++) {
            qreal yDistance;
            if (reverse) {
                yDistance = y - center;
            } else {
                yDistance = center - y;
            }
            if (y==center) {
                matrix(0, y) = 0;
            } else {
                matrix(0, y) = (1/yDistance);
            }
        }
    } else {
        for (int y = 0; y < kernelSize; y++) {
            for (int x=0; x<kernelSize; x++) {
                if (x==center && y==center) {
                    matrix(x, y) = 0;
                } else {
                    qreal xD, yD;
                    if (reverse) {
                        xD = x - center;
                        yD = y - center;
                    } else {
                        xD = center - x;
                        yD = center - y;
                    }
                    matrix(x, y) = yD / (xD*xD + yD*yD);
                }
            }
        }
    }
    return matrix;
}

References kernelSizeFromRadius(), KIS_ASSERT_RECOVER_NOOP, Prewitt, and Simple.

kernelSizeFromRadius()

int KisEdgeDetectionKernel::kernelSizeFromRadius ( qreal radius )

static

Definition at line 172 of file kis_edge_detection_kernel.cpp.

{
    return qMax((int)(2 * ceil(sigmaFromRadius(radius)) + 1), 3);
}

References sigmaFromRadius().

sigmaFromRadius()

qreal KisEdgeDetectionKernel::sigmaFromRadius ( qreal radius )

static

Definition at line 177 of file kis_edge_detection_kernel.cpp.

{
    return 0.3 * radius + 0.3;
}

---

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

• libs/image/kis_edge_detection_kernel.h
• libs/image/kis_edge_detection_kernel.cpp