KisGrowUntilDarkestPixelSelectionFilter Class Reference

Filter that dilates a selection and that can stop dilating adaptively at areas of higher darkness or opacity. This is useful to grow selections used to fill line art, since the growing will stop most likely inside the lines, without overflowing to the other side. More...

#include <kis_selection_filters.h>

Inheritance diagram for KisGrowUntilDarkestPixelSelectionFilter:

Public Member Functions
QRect	changeRect (const QRect &rect, KisDefaultBoundsBaseSP defaultBounds) override
	KisGrowUntilDarkestPixelSelectionFilter (qint32 radius, KisPaintDeviceSP referenceDevice)
KUndo2MagicString	name () override
void	process (KisPixelSelectionSP pixelSelection, const QRect &rect) override
Public Member Functions inherited from KisSelectionFilter
virtual	~KisSelectionFilter ()

Private Attributes
qint32	m_radius
KisPaintDeviceSP	m_referenceDevice

Additional Inherited Members
Protected Member Functions inherited from KisSelectionFilter
void	computeBorder (qint32 *circ, qint32 xradius, qint32 yradius)
void	computeTransition (quint8 *transition, quint8 **buf, qint32 width)
void	rotatePointers (quint8 **p, quint32 n)

Detailed Description

Filter that dilates a selection and that can stop dilating adaptively at areas of higher darkness or opacity. This is useful to grow selections used to fill line art, since the growing will stop most likely inside the lines, without overflowing to the other side.

Definition at line 226 of file kis_selection_filters.h.

Constructor & Destructor Documentation

KisGrowUntilDarkestPixelSelectionFilter()

KisGrowUntilDarkestPixelSelectionFilter::KisGrowUntilDarkestPixelSelectionFilter	(	qint32	radius,
		KisPaintDeviceSP	referenceDevice )

Parameters

radius	The radius of the structuring element used for the dilation.
referenceDevice	The device used to check if the dilation reached the darkest or most opaque pixels.

Definition at line 1191 of file kis_selection_filters.cpp.

    : m_radius(radius)
    , m_referenceDevice(referenceDevice)
{
}

Member Function Documentation

changeRect()

QRect KisGrowUntilDarkestPixelSelectionFilter::changeRect ( const QRect & rect, KisDefaultBoundsBaseSP defaultBounds )

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 1203 of file kis_selection_filters.cpp.

{
    Q_UNUSED(defaultBounds);
 
    return rect.adjusted(-m_radius, -m_radius, m_radius, m_radius);
}

References m_radius.

name()

KUndo2MagicString KisGrowUntilDarkestPixelSelectionFilter::name ( )

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 1198 of file kis_selection_filters.cpp.

{
    return kundo2_i18n("Grow Selection Until Darkest Pixel");
}

References kundo2_i18n().

process()

void KisGrowUntilDarkestPixelSelectionFilter::process ( KisPixelSelectionSP pixelSelection, const QRect & rect )

overridevirtual

Implements KisSelectionFilter.

Definition at line 1210 of file kis_selection_filters.cpp.

{
    // Copy the original selection. We will grow this adaptively until the
    // darkest or more opaque pixels or until the maximum grow is reached.
    KisPixelSelectionSP mask = new KisPixelSelection(*pixelSelection);
    // Grow the original selection normally. At the end this selection will be
    // masked with the adaptively grown mask. We cannot grow adaptively this
    // selection directly since it may have semi-transparent or soft edges.
    // Those need to be retained in the final selection. This normally grown
    // selection is also used as a stop condition for the adaptive mask, which
    // cannot grow pass the limits of the this normally grown selection.
    KisGrowSelectionFilter growFilter(m_radius, m_radius);
    growFilter.process(pixelSelection, rect);
 
    const qint32 maskScanLineSize = rect.width();
    const KoColorSpace *referenceColorSpace = m_referenceDevice->colorSpace();
    const qint32 referencePixelSize = referenceColorSpace->pixelSize();
    const qint32 referenceScanLineSize = maskScanLineSize * referencePixelSize;
    // Some buffers to store the working scanlines
    QVector<quint8> maskBuffer(maskScanLineSize * 2);
    QVector<quint8> referenceBuffer(referenceScanLineSize * 2);
    QVector<quint8> selectionBuffer(maskScanLineSize);
    quint8 *maskScanLines[2] = {maskBuffer.data(), maskBuffer.data() + maskScanLineSize};
    quint8 *referenceScanLines[2] = {referenceBuffer.data(), referenceBuffer.data() + referenceScanLineSize};
    quint8 *selectionScanLine = selectionBuffer.data();
    // Helper function to test if a pixel can be selected
    auto testSelectPixel = 
        [referenceColorSpace]
        (quint8 pixelOpacity, quint8 pixelIntensity,
         const quint8 *testMaskPixel, const quint8 *testReferencePixel) -> bool
        {
            if (*testMaskPixel) {
                const quint8 testOpacity = referenceColorSpace->opacityU8(testReferencePixel);
                if (pixelOpacity >= testOpacity) {
                    // Special case for when the neighbor pixel is fully transparent.
                    // In that case do not compare the intensity
                    if (testOpacity == MIN_SELECTED) {
                        return true;
                    }
                    // If the opacity test passes we still have to perform the
                    // intensity test
                    const quint8 testIntensity = referenceColorSpace->intensity8(testReferencePixel);
                    if (pixelIntensity <= testIntensity) {
                        return true;
                    }
                }
            }
            return false;
        };
 
    // Top-left to bottom-right pass
    // First row
    {
        mask->readBytes(maskScanLines[1], rect.left(), rect.top(), maskScanLineSize, 1);
        m_referenceDevice->readBytes(referenceScanLines[1], rect.left(), rect.top(), maskScanLineSize, 1);
        pixelSelection->readBytes(selectionScanLine, rect.left(), rect.top(), maskScanLineSize, 1);
        quint8 *currentMaskScanLineBegin = maskScanLines[1];
        quint8 *currentMaskScanLineEnd = maskScanLines[1] + maskScanLineSize;
        quint8 *currentReferenceScanLineBegin = referenceScanLines[1];
        quint8 *currentSelectionScanLineBegin = selectionScanLine;
        // First pixel
        ++currentMaskScanLineBegin;
        currentReferenceScanLineBegin += referencePixelSize;
        ++currentSelectionScanLineBegin;
        // Rest of pixels
        while (currentMaskScanLineBegin != currentMaskScanLineEnd) {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                       currentMaskScanLineBegin - 1,
                                                       currentReferenceScanLineBegin - referencePixelSize);
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            ++currentMaskScanLineBegin;
            currentReferenceScanLineBegin += referencePixelSize;
            ++currentSelectionScanLineBegin;
        }
        mask->writeBytes(maskScanLines[1], rect.left(), rect.top(), maskScanLineSize, 1);
    }
    // Rest of rows
    for (qint32 y = rect.top() + 1; y <= rect.bottom(); ++y) {
        rotatePointers(maskScanLines, 2);
        rotatePointers(referenceScanLines, 2);
        mask->readBytes(maskScanLines[1], rect.left(), y, maskScanLineSize, 1);
        m_referenceDevice->readBytes(referenceScanLines[1], rect.left(), y, maskScanLineSize, 1);
        pixelSelection->readBytes(selectionScanLine, rect.left(), y, maskScanLineSize, 1);
        quint8 *currentMaskScanLineBegin = maskScanLines[1];
        quint8 *currentMaskScanLineEnd = maskScanLines[1] + maskScanLineSize;
        quint8 *currentReferenceScanLineBegin = referenceScanLines[1];
        quint8 *topMaskScanLineBegin = maskScanLines[0];
        quint8 *topReferenceScanLineBegin = referenceScanLines[0];
        quint8 *currentSelectionScanLineBegin = selectionScanLine;
        // First pixel
        {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                       topMaskScanLineBegin,
                                                       topReferenceScanLineBegin);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                        topMaskScanLineBegin + 1,
                                                        topReferenceScanLineBegin + referencePixelSize);
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            ++currentMaskScanLineBegin;
            currentReferenceScanLineBegin += referencePixelSize;
            ++topMaskScanLineBegin;
            topReferenceScanLineBegin += referencePixelSize;
            ++currentSelectionScanLineBegin;
        }
        // Rest of pixels
        while (currentMaskScanLineBegin != (currentMaskScanLineEnd - 1)) {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity, 
                                                       topMaskScanLineBegin - 1,
                                                       topReferenceScanLineBegin - referencePixelSize);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                      topMaskScanLineBegin,
                                                      topReferenceScanLineBegin);
                    if (!pixelIsSelected) {
                        pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                          topMaskScanLineBegin + 1,
                                                          topReferenceScanLineBegin + referencePixelSize);
                        if (!pixelIsSelected) {
                            pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                              currentMaskScanLineBegin - 1,
                                                              currentReferenceScanLineBegin - referencePixelSize);
                        }
                    }
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            ++currentMaskScanLineBegin;
            currentReferenceScanLineBegin += referencePixelSize;
            ++topMaskScanLineBegin;
            topReferenceScanLineBegin += referencePixelSize;
            ++currentSelectionScanLineBegin;
        }
        // Last pixel
        {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity, 
                                                       topMaskScanLineBegin - 1,
                                                       topReferenceScanLineBegin - referencePixelSize);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                      topMaskScanLineBegin,
                                                      topReferenceScanLineBegin);
                    if (!pixelIsSelected) {
                        pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                          currentMaskScanLineBegin - 1,
                                                          currentReferenceScanLineBegin - referencePixelSize);
                    }
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
        }
        mask->writeBytes(maskScanLines[1], rect.left(), y, maskScanLineSize, 1);
    }
 
    // Bottom-right to top-left pass
    // Last row
    {
        mask->readBytes(maskScanLines[1], rect.left(), rect.bottom(), maskScanLineSize, 1);
        m_referenceDevice->readBytes(referenceScanLines[1], rect.left(), rect.bottom(), maskScanLineSize, 1);
        pixelSelection->readBytes(selectionScanLine, rect.left(), rect.bottom(), maskScanLineSize, 1);
        quint8 *currentMaskScanLineBegin = maskScanLines[1] + maskScanLineSize - 1;
        quint8 *currentMaskScanLineEnd = maskScanLines[1] - 1;
        quint8 *currentReferenceScanLineBegin = referenceScanLines[1] + referenceScanLineSize - referencePixelSize;
        quint8 *currentSelectionScanLineBegin = selectionScanLine + maskScanLineSize - 1;
        // Last pixel
        --currentMaskScanLineBegin;
        currentReferenceScanLineBegin -= referencePixelSize;
        --currentSelectionScanLineBegin;
        // Rest of pixels
        while (currentMaskScanLineBegin != currentMaskScanLineEnd) {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                       currentMaskScanLineBegin + 1,
                                                       currentReferenceScanLineBegin + referencePixelSize);
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            --currentMaskScanLineBegin;
            currentReferenceScanLineBegin -= referencePixelSize;
            --currentSelectionScanLineBegin;
        }
        mask->writeBytes(maskScanLines[1], rect.left(), rect.top(), maskScanLineSize, 1);
    }
    // Rest of rows
    for (qint32 y = rect.bottom() - 1; y >= rect.top(); --y) {
        rotatePointers(maskScanLines, 2);
        rotatePointers(referenceScanLines, 2);
        mask->readBytes(maskScanLines[1], rect.left(), y, maskScanLineSize, 1);
        m_referenceDevice->readBytes(referenceScanLines[1], rect.left(), y, maskScanLineSize, 1);
        pixelSelection->readBytes(selectionScanLine, rect.left(), y, maskScanLineSize, 1);
        quint8 *currentMaskScanLineBegin = maskScanLines[1] + maskScanLineSize - 1;
        quint8 *currentMaskScanLineEnd = maskScanLines[1] - 1;
        quint8 *currentReferenceScanLineBegin = referenceScanLines[1] + referenceScanLineSize - referencePixelSize;
        quint8 *bottomMaskScanLineBegin = maskScanLines[0] + maskScanLineSize - 1;
        quint8 *bottomReferenceScanLineBegin = referenceScanLines[0] + referenceScanLineSize - referencePixelSize;
        quint8 *currentSelectionScanLineBegin = selectionScanLine + maskScanLineSize - 1;
        // Last pixel
        {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                       bottomMaskScanLineBegin,
                                                       bottomReferenceScanLineBegin);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                      bottomMaskScanLineBegin - 1,
                                                      bottomReferenceScanLineBegin - referencePixelSize);
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            --currentMaskScanLineBegin;
            currentReferenceScanLineBegin -= referencePixelSize;
            --bottomMaskScanLineBegin;
            bottomReferenceScanLineBegin -= referencePixelSize;
            --currentSelectionScanLineBegin;
        }
        // Rest of pixels
        while (currentMaskScanLineBegin != (currentMaskScanLineEnd + 1)) {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity, 
                                                       bottomMaskScanLineBegin + 1,
                                                       bottomReferenceScanLineBegin + referencePixelSize);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                      bottomMaskScanLineBegin,
                                                      bottomReferenceScanLineBegin);
                    if (!pixelIsSelected) {
                        pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                          bottomMaskScanLineBegin - 1,
                                                          bottomReferenceScanLineBegin - referencePixelSize);
                        if (!pixelIsSelected) {
                            pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                              currentMaskScanLineBegin + 1,
                                                              currentReferenceScanLineBegin + referencePixelSize);
                        }
                    }
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
            --currentMaskScanLineBegin;
            currentReferenceScanLineBegin -= referencePixelSize;
            --bottomMaskScanLineBegin;
            bottomReferenceScanLineBegin -= referencePixelSize;
            --currentSelectionScanLineBegin;
        }
        // First pixel
        {
            if (*currentMaskScanLineBegin == MIN_SELECTED && *currentSelectionScanLineBegin != MIN_SELECTED) {
                const quint8 currentOpacity = referenceColorSpace->opacityU8(currentReferenceScanLineBegin);
                const quint8 currentIntensity = referenceColorSpace->intensity8(currentReferenceScanLineBegin);
 
                bool pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity, 
                                                       bottomMaskScanLineBegin + 1,
                                                       bottomReferenceScanLineBegin + referencePixelSize);
                if (!pixelIsSelected) {
                    pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                      bottomMaskScanLineBegin,
                                                      bottomReferenceScanLineBegin);
                    if (!pixelIsSelected) {
                        pixelIsSelected = testSelectPixel(currentOpacity, currentIntensity,
                                                            currentMaskScanLineBegin + 1,
                                                            currentReferenceScanLineBegin + referencePixelSize);
                    }
                }
                if (pixelIsSelected) {
                    *currentMaskScanLineBegin = MAX_SELECTED;
                }
            }
        }
        mask->writeBytes(maskScanLines[1], rect.left(), y, maskScanLineSize, 1);
    }
 
    // Combine the adaptively grown mask with the normally grown mask. The
    // adaptively grown mask is used as a binary mask to erase some of the
    // pixels of the normally grown mask
    {
        KisSequentialConstIterator it1(mask, rect);
        KisSequentialIterator it2(pixelSelection, rect);
        while (it1.nextPixel() && it2.nextPixel()) {
            *it2.rawData() *= (*it1.rawDataConst() != MIN_SELECTED);
        }
    }
}

References KisPaintDevice::colorSpace(), KoColorSpace::intensity8(), m_radius, m_referenceDevice, MAX_SELECTED, MIN_SELECTED, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KoColorSpace::pixelSize(), KisGrowSelectionFilter::process(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), KisPaintDevice::readBytes(), KisSelectionFilter::rotatePointers(), and KisPaintDevice::writeBytes().

Member Data Documentation

m_radius

qint32 KisGrowUntilDarkestPixelSelectionFilter::m_radius

private

Definition at line 241 of file kis_selection_filters.h.

m_referenceDevice

KisPaintDeviceSP KisGrowUntilDarkestPixelSelectionFilter::m_referenceDevice

private

Definition at line 242 of file kis_selection_filters.h.

---

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

• libs/image/kis_selection_filters.h
• libs/image/kis_selection_filters.cpp