KisEncloseAndFillPainter::Private Class Reference

Public Member Functions
void	applyPostProcessing (KisPixelSelectionSP mask, KisPaintDeviceSP referenceDevice) const
void	computeEnclosedRegionsMask (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
QVector< QPoint >	getEnclosingContourPoints (KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect) const
void	invertIfNeeded (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect) const
void	invertMaskRect (KisPixelSelectionSP resultMask, const QRect &rect) const
	Private (KisEncloseAndFillPainter *q)
void	removeContourRegions (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	removeContourRegions (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QVector< QPoint > &enclosingPoints, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectAllRegions (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectAllRegionsExceptFilledWithSpecificColor (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
template<typename SelectionPolicy >
void	selectAllRegionsExceptFilledWithSpecificColorGeneric (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, SelectionPolicy selectionPolicy) const
void	selectAllRegionsExceptFilledWithSpecificColorOrTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectAllRegionsExceptFilledWithTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
template<typename SelectionPolicy >
int	selectDissimilarRegions (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, SelectionPolicy selectionPolicy) const
void	selectRegionsFilledWithSpecificColor (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
template<typename SelectionPolicy >
void	selectRegionsFilledWithSpecificColorGeneric (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, SelectionPolicy selectionPolicy) const
void	selectRegionsFilledWithSpecificColorOrTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectRegionsFilledWithTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectRegionsFromContour (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectRegionsFromContour (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QVector< QPoint > &enclosingPoints, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectRegionsFromContourUntilColor (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, const KoColor &color) const
void	selectRegionsFromContourUntilColor (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QVector< QPoint > &enclosingPoints, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, const KoColor &color) const
void	selectRegionsFromContourUntilColorOrTransparent (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, const KoColor &color) const
void	selectRegionsFromContourUntilColorOrTransparent (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QVector< QPoint > &enclosingPoints, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, const KoColor &color) const
void	selectRegionsSurroundedBySpecificColor (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
template<typename SelectionPolicy >
void	selectRegionsSurroundedBySpecificColorGeneric (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, SelectionPolicy selectionPolicy, bool colorOrTransparent=false) const
void	selectRegionsSurroundedBySpecificColorOrTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
void	selectRegionsSurroundedByTransparent (KisPixelSelectionSP resultMask, QRect *resultMaskRect, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice) const
template<typename SelectionPolicy >
int	selectSimilarRegions (KisPixelSelectionSP resultMask, KisPixelSelectionSP enclosingMask, const QRect &enclosingMaskRect, KisPaintDeviceSP referenceDevice, SelectionPolicy selectionPolicy) const

Public Attributes
QRect	imageRect
KisEncloseAndFillPainter *	q {nullptr}
KoColor	regionSelectionColor
bool	regionSelectionIncludeContourRegions {true}
bool	regionSelectionIncludeSurroundingRegions {true}
bool	regionSelectionInvert {false}
RegionSelectionMethod	regionSelectionMethod {SelectAllRegions}

Detailed Description

Definition at line 126 of file KisEncloseAndFillPainter.cpp.

Constructor & Destructor Documentation

Private()

KisEncloseAndFillPainter::Private::Private ( KisEncloseAndFillPainter * q )

inline

Definition at line 137 of file KisEncloseAndFillPainter.cpp.

: q(q) {}

Member Function Documentation

applyPostProcessing()

void KisEncloseAndFillPainter::Private::applyPostProcessing	(	KisPixelSelectionSP	mask,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 873 of file KisEncloseAndFillPainter.cpp.

{
    if (q->sizemod() > 0) {
        if (q->stopGrowingAtDarkestPixel()) {
            KisGrowUntilDarkestPixelSelectionFilter biggy(q->sizemod(), referenceDevice);
            biggy.process(
                mask, 
                mask->selectedRect().adjusted(
                    -q->sizemod(), -q->sizemod(), q->sizemod(), q->sizemod()
                )
            );
        } else {
            KisGrowSelectionFilter biggy(q->sizemod(), q->sizemod());
            biggy.process(
                mask,
                mask->selectedRect().adjusted(
                    -q->sizemod(), -q->sizemod(), q->sizemod(), q->sizemod()
                )
            );
        }
    } else if (q->sizemod() < 0) {
        KisShrinkSelectionFilter tiny(-q->sizemod(), -q->sizemod(), false);
        tiny.process(mask, mask->selectedRect());
    }
    // Since the feathering already smooths the selection, the antiAlias
    // is not applied if we must feather
    if (q->feather() > 0) {
        KisFeatherSelectionFilter feathery(q->feather());
        feathery.process(mask, mask->selectedRect().adjusted(-q->feather(), -q->feather(), q->feather(), q->feather()));
    } else if (q->antiAlias()) {
        KisAntiAliasSelectionFilter antiAliasFilter;
        antiAliasFilter.process(mask, mask->selectedRect());
    }
}

References KisFeatherSelectionFilter::process(), KisGrowSelectionFilter::process(), KisShrinkSelectionFilter::process(), KisAntiAliasSelectionFilter::process(), KisGrowUntilDarkestPixelSelectionFilter::process(), KisPainter::q, and KisPixelSelection::selectedRect().

computeEnclosedRegionsMask()

void KisEncloseAndFillPainter::Private::computeEnclosedRegionsMask	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 463 of file KisEncloseAndFillPainter.cpp.

{
    // Create the regions mask
    switch (regionSelectionMethod) {
        case SelectAllRegions:
            selectAllRegions(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsFilledWithSpecificColor:
            selectRegionsFilledWithSpecificColor(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsFilledWithTransparent:
            selectRegionsFilledWithTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsFilledWithSpecificColorOrTransparent:
            selectRegionsFilledWithSpecificColorOrTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectAllRegionsExceptFilledWithSpecificColor:
            selectAllRegionsExceptFilledWithSpecificColor(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectAllRegionsExceptFilledWithTransparent:
            selectAllRegionsExceptFilledWithTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectAllRegionsExceptFilledWithSpecificColorOrTransparent:
            selectAllRegionsExceptFilledWithSpecificColorOrTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsSurroundedBySpecificColor:
            selectRegionsSurroundedBySpecificColor(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsSurroundedByTransparent:
            selectRegionsSurroundedByTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        case SelectRegionsSurroundedBySpecificColorOrTransparent:
            selectRegionsSurroundedBySpecificColorOrTransparent(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice);
            break;
        default: return;
    }
}

References regionSelectionMethod, selectAllRegions(), KisEncloseAndFillPainter::SelectAllRegions, selectAllRegionsExceptFilledWithSpecificColor(), KisEncloseAndFillPainter::SelectAllRegionsExceptFilledWithSpecificColor, selectAllRegionsExceptFilledWithSpecificColorOrTransparent(), KisEncloseAndFillPainter::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent, selectAllRegionsExceptFilledWithTransparent(), KisEncloseAndFillPainter::SelectAllRegionsExceptFilledWithTransparent, selectRegionsFilledWithSpecificColor(), KisEncloseAndFillPainter::SelectRegionsFilledWithSpecificColor, selectRegionsFilledWithSpecificColorOrTransparent(), KisEncloseAndFillPainter::SelectRegionsFilledWithSpecificColorOrTransparent, selectRegionsFilledWithTransparent(), KisEncloseAndFillPainter::SelectRegionsFilledWithTransparent, selectRegionsSurroundedBySpecificColor(), KisEncloseAndFillPainter::SelectRegionsSurroundedBySpecificColor, selectRegionsSurroundedBySpecificColorOrTransparent(), KisEncloseAndFillPainter::SelectRegionsSurroundedBySpecificColorOrTransparent, selectRegionsSurroundedByTransparent(), and KisEncloseAndFillPainter::SelectRegionsSurroundedByTransparent.

getEnclosingContourPoints()

QVector< QPoint > KisEncloseAndFillPainter::Private::getEnclosingContourPoints	(	KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect ) const

Definition at line 794 of file KisEncloseAndFillPainter.cpp.

{
    QVector<QPoint> enclosingPoints;
    const int scanlineWidth = enclosingMaskRect.width() + 2;
    QVector<quint8> buffer(scanlineWidth * 3);
    quint8 *scanlines[3] = {buffer.data(), buffer.data() + scanlineWidth, buffer.data() + scanlineWidth * 2};
    // Initialize the buffer
    // Top, outside row
    memset(scanlines[0], MIN_SELECTED, scanlineWidth);
    // Middle row
    // Left, outside pixel
    *(scanlines[1]) = MIN_SELECTED;
    // Middle, inside pixels
    enclosingMask->readBytes(scanlines[1] + 1, enclosingMaskRect.x(), enclosingMaskRect.y(), enclosingMaskRect.width(), 1);
    // Right, outside pixel
    *(scanlines[2] - 1) = MIN_SELECTED;
    // Bottom row
    if (enclosingMaskRect.height() == 1) {
        // Bottom, outside row
        memset(scanlines[2], MIN_SELECTED, scanlineWidth);
    } else {
        // Left, outside pixel
        *(scanlines[2]) = MIN_SELECTED;
        // Middle, inside pixels
        enclosingMask->readBytes(scanlines[2] + 1, enclosingMaskRect.x(), enclosingMaskRect.y() + 1, enclosingMaskRect.width(), 1);
        // Right, outside pixel
        *(scanlines[2] + scanlineWidth - 1) = MIN_SELECTED;
    }
 
    for (int y = 0; y < enclosingMaskRect.height(); ++y) {
        if (y > 0) {
            // Rotate pointers
            quint8 *tmp = scanlines[0];
            scanlines[0] = scanlines[1];
            scanlines[1] = scanlines[2];
            scanlines[2] = tmp;
            // Read new row
            if (y == enclosingMaskRect.height() - 1) {
                // Bottom, outside row
                memset(scanlines[2], MIN_SELECTED, scanlineWidth);
            } else {
                // Left, outside pixel
                *(scanlines[2]) = MIN_SELECTED;
                // Middle, inside pixels
                enclosingMask->readBytes(scanlines[2] + 1, enclosingMaskRect.x(), enclosingMaskRect.y() + y + 1, enclosingMaskRect.width(), 1);
                // Right, outside pixel
                *(scanlines[2] + scanlineWidth - 1) = MIN_SELECTED;
            }
        }
        const quint8 *topPixel = scanlines[0] + 1;
        const quint8 *middlePixel = scanlines[1] + 1;
        const quint8 *bottomPixel = scanlines[2] + 1;
        for (int x = 0; x < enclosingMaskRect.width(); ++x, ++topPixel, ++middlePixel, ++bottomPixel) {
            // Continue if the current pixel is not in the selection
            if (*middlePixel == MIN_SELECTED) {
                continue;
            }
            // Get all eight neighbor pixels. If at least one of them is not
            // in the selection then the current pixel is a border pixel and
            // we add it to the list
            quint8 neighbors = 0;
            neighbors |= (*(topPixel    - 1) == MIN_SELECTED) << 7;
            neighbors |= (*(topPixel       ) == MIN_SELECTED) << 6;
            neighbors |= (*(topPixel    + 1) == MIN_SELECTED) << 5;
            neighbors |= (*(middlePixel - 1) == MIN_SELECTED) << 4;
            neighbors |= (*(middlePixel + 1) == MIN_SELECTED) << 3;
            neighbors |= (*(bottomPixel - 1) == MIN_SELECTED) << 2;
            neighbors |= (*(bottomPixel    ) == MIN_SELECTED) << 1;
            neighbors |= (*(bottomPixel + 1) == MIN_SELECTED) << 0;
            if (neighbors != 0) {
                enclosingPoints.push_back(QPoint(enclosingMaskRect.x() + x, enclosingMaskRect.y() + y));
            }
        }
    }
 
    return enclosingPoints;
}

References MIN_SELECTED, and KisPaintDevice::readBytes().

invertIfNeeded()

void KisEncloseAndFillPainter::Private::invertIfNeeded	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect ) const

Definition at line 909 of file KisEncloseAndFillPainter.cpp.

{
    if (!regionSelectionInvert) {
        return;
    }
    invertMaskRect(resultMask, enclosingMaskRect);
    // Since, after inverting, the mask includes the region outside the enclosing
    // mask, we must intersect the current mask with the enclosing mask. The result
    // is a mask that includes all the closed regions inside the enclosing mask
    resultMask->applySelection(enclosingMask, SELECTION_INTERSECT);
}

References KisPixelSelection::applySelection(), KisEncloseAndFillPainter::regionSelectionInvert(), and SELECTION_INTERSECT.

invertMaskRect()

void KisEncloseAndFillPainter::Private::invertMaskRect	(	KisPixelSelectionSP	resultMask,
		const QRect &	rect ) const

Definition at line 1125 of file KisEncloseAndFillPainter.cpp.

{
    KisSequentialIterator resultMaskIterator(resultMask, rect);
    while (resultMaskIterator.nextPixel()) {
        *resultMaskIterator.rawData() = MAX_SELECTED - *resultMaskIterator.oldRawData();
    }
}

References MAX_SELECTED, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

removeContourRegions() [1/2]

void KisEncloseAndFillPainter::Private::removeContourRegions	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 1101 of file KisEncloseAndFillPainter.cpp.

{
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    removeContourRegions(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice);
}

removeContourRegions() [2/2]

void KisEncloseAndFillPainter::Private::removeContourRegions	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QVector< QPoint > &	enclosingPoints,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 1110 of file KisEncloseAndFillPainter.cpp.

{
    if (enclosingPoints.isEmpty()) {
        return;
    }
 
    KisPixelSelectionSP contourRegionsMask = new KisPixelSelection(new KisSelectionDefaultBounds(enclosingMask));
    selectRegionsFromContour(contourRegionsMask, enclosingMask, enclosingMaskRect, referenceDevice);
    resultMask->applySelection(contourRegionsMask, SELECTION_SUBTRACT);
}

References KisPixelSelection::applySelection(), and SELECTION_SUBTRACT.

selectAllRegions()

void KisEncloseAndFillPainter::Private::selectAllRegions	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 505 of file KisEncloseAndFillPainter.cpp.

{
    if (regionSelectionIncludeContourRegions && regionSelectionInvert) {
        // Nothing is selected in this case, so return early
        return;
    }
    resultMask->applySelection(enclosingMask, SELECTION_REPLACE);
    if (!regionSelectionIncludeContourRegions) {
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(enclosingMask));
        selectRegionsFromContour(mask, enclosingMask, enclosingMaskRect, referenceDevice);
        resultMask->applySelection(mask, SELECTION_SUBTRACT);
    }
    if (resultMaskRect) {
        *resultMaskRect = resultMask->selectedExactRect();
    }
}

References KisPixelSelection::applySelection(), KisEncloseAndFillPainter::regionSelectionIncludeContourRegions(), KisEncloseAndFillPainter::regionSelectionInvert(), KisPixelSelection::selectedExactRect(), SELECTION_REPLACE, and SELECTION_SUBTRACT.

selectAllRegionsExceptFilledWithSpecificColor()

void KisEncloseAndFillPainter::Private::selectAllRegionsExceptFilledWithSpecificColor	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 615 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectAllRegionsExceptFilledWithSpecificColorGeneric()

template<typename SelectionPolicy >

void KisEncloseAndFillPainter::Private::selectAllRegionsExceptFilledWithSpecificColorGeneric	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		SelectionPolicy	selectionPolicy ) const

Definition at line 668 of file KisEncloseAndFillPainter.cpp.

{
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    // Remove the regions that touch the enclosing area
    if (selectDissimilarRegions(resultMask, enclosingMask, enclosingMaskRect, referenceDevice, selectionPolicy) == 0) {
        if (resultMaskRect) {
            *resultMaskRect = QRect();
        }
        return;
    }
    if (!regionSelectionIncludeContourRegions) {
        // Here we don't use removeContourRegions because the contour regions
        // in the mask may include multiple connected color regions
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(enclosingMask));
        selectRegionsFromContour(mask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice);
        resultMask->applySelection(mask, SELECTION_SUBTRACT);
    }
    if (resultMaskRect) {
        *resultMaskRect = resultMask->selectedExactRect();
    }
}

References KisPixelSelection::applySelection(), KisEncloseAndFillPainter::regionSelectionIncludeContourRegions(), KisPixelSelection::selectedExactRect(), and SELECTION_SUBTRACT.

selectAllRegionsExceptFilledWithSpecificColorOrTransparent()

void KisEncloseAndFillPainter::Private::selectAllRegionsExceptFilledWithSpecificColorOrTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 649 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    // Here we must compute the specific color and transparent masks separately
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorOrTransparentDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<SpecificColorOrTransparentDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectAllRegionsExceptFilledWithTransparent()

void KisEncloseAndFillPainter::Private::selectAllRegionsExceptFilledWithTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 632 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), KoColor::createTransparent(referenceDevice->colorSpace()), q->fillThreshold());
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), KoColor::createTransparent(referenceDevice->colorSpace()), q->fillThreshold(), softness);
        selectAllRegionsExceptFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KoColor::createTransparent(), and KisPainter::q.

selectDissimilarRegions()

template<typename SelectionPolicy >

int KisEncloseAndFillPainter::Private::selectDissimilarRegions	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		SelectionPolicy	selectionPolicy ) const

Definition at line 947 of file KisEncloseAndFillPainter.cpp.

{
    KisSequentialIterator resultMaskIterator(resultMask, enclosingMaskRect);
    KisSequentialConstIterator enclosingMaskIterator(enclosingMask, enclosingMaskRect);
    KisSequentialConstIterator referenceDeviceIterator(referenceDevice, enclosingMaskRect);
    int nPixels = 0;
    // Select all the pixels using the given selection policy
    while (resultMaskIterator.nextPixel() && enclosingMaskIterator.nextPixel() && referenceDeviceIterator.nextPixel()) {
        if (*enclosingMaskIterator.oldRawData() == MIN_SELECTED) {
            continue;
        }
        const quint8 selection = MAX_SELECTED - selectionPolicy.getSelectionFor(referenceDeviceIterator.oldRawData());
        if (selection > MIN_SELECTED) {
            *resultMaskIterator.rawData() = selection;
            ++nPixels;
        }
    }
    return nPixels;
}

References MAX_SELECTED, MIN_SELECTED, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisPainter::selection.

selectRegionsFilledWithSpecificColor()

void KisEncloseAndFillPainter::Private::selectRegionsFilledWithSpecificColor	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 526 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectRegionsFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectRegionsFilledWithSpecificColorGeneric()

template<typename SelectionPolicy >

void KisEncloseAndFillPainter::Private::selectRegionsFilledWithSpecificColorGeneric	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		SelectionPolicy	selectionPolicy ) const

Definition at line 591 of file KisEncloseAndFillPainter.cpp.

{
    // Select all the pixels using the given selection policy and
    // return if there are no selected pixels
    if (selectSimilarRegions(resultMask, enclosingMask, enclosingMaskRect, referenceDevice, selectionPolicy) == 0) {
        if (resultMaskRect) {
            *resultMaskRect = QRect();
        }
        return;
    }
    // Remove the regions that touch the enclosing area
    if (!regionSelectionIncludeContourRegions) {
        removeContourRegions(resultMask, enclosingMask, enclosingMaskRect, referenceDevice);
    }
    if (resultMaskRect) {
        *resultMaskRect = resultMask->selectedExactRect();
    }
}

References KisEncloseAndFillPainter::regionSelectionIncludeContourRegions(), and KisPixelSelection::selectedExactRect().

selectRegionsFilledWithSpecificColorOrTransparent()

void KisEncloseAndFillPainter::Private::selectRegionsFilledWithSpecificColorOrTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 560 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    // Here we must compute the specific color and transparent masks separately
    // so that the contour regions can be removed independently if they are
    // transparent or of the specific color and are connected
    KisPixelSelectionSP resultMaskTransparent = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorDifferencePolicy> colorPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsFilledWithSpecificColorGeneric(resultMask, nullptr, enclosingMask, enclosingMaskRect, referenceDevice, colorPolicy);
        HardSelectionPolicy<TransparentForHalosDifferencePolicy> transparentPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsFilledWithSpecificColorGeneric(resultMaskTransparent, nullptr, enclosingMask, enclosingMaskRect, referenceDevice, transparentPolicy);
    } else {
        SoftSelectionPolicy<SpecificColorDifferencePolicy> colorPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectRegionsFilledWithSpecificColorGeneric(resultMask, nullptr, enclosingMask, enclosingMaskRect, referenceDevice, colorPolicy);
        HardSelectionPolicy<TransparentForHalosDifferencePolicy> transparentPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsFilledWithSpecificColorGeneric(resultMaskTransparent, nullptr, enclosingMask, enclosingMaskRect, referenceDevice, transparentPolicy);
    }
    // Compose the masks
    resultMask->applySelection(resultMaskTransparent, SELECTION_ADD);
    if (resultMaskRect) {
        *resultMaskRect = resultMask->selectedExactRect();
    }
}

References KisPixelSelection::applySelection(), KisPaintDevice::colorSpace(), KisPainter::q, KisEncloseAndFillPainter::regionSelectionColor(), KisPixelSelection::selectedExactRect(), and SELECTION_ADD.

selectRegionsFilledWithTransparent()

void KisEncloseAndFillPainter::Private::selectRegionsFilledWithTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 543 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectRegionsFilledWithSpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectRegionsFromContour() [1/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContour	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 971 of file KisEncloseAndFillPainter.cpp.

{
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    selectRegionsFromContour(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice);
}

selectRegionsFromContour() [2/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContour	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QVector< QPoint > &	enclosingPoints,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 980 of file KisEncloseAndFillPainter.cpp.

{
    if (enclosingPoints.isEmpty()) {
        return;
    }
    const QRect inclusionRect = q->device()->defaultBounds()->wrapAroundMode()
                                ? enclosingMaskRect
                                : imageRect;
    // Here we just fill all the areas from the border towards inside
    for (const QPoint &point : enclosingPoints) {
        if (!inclusionRect.contains(point)) {
            continue;
        }
        // Continue if the region under the point was already filled
        if (*(resultMask->pixel(point).data()) == MAX_SELECTED) {
            continue;
        }
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
        KisScanlineFill gc(referenceDevice, point, inclusionRect);
        gc.setThreshold(q->fillThreshold());
        gc.setOpacitySpread(q->opacitySpread());
        gc.setCloseGap(q->closeGap());
        // Use the enclosing mask as boundary so that we don't fill
        // potentially large regions on the outside
        gc.fillSelection(mask, enclosingMask);
        resultMask->applySelection(mask, SELECTION_ADD);
    }
}

References KisPixelSelection::applySelection(), KisPaintDevice::defaultBounds(), KisPainter::device, KisScanlineFill::fillSelection(), MAX_SELECTED, KisPaintDevice::pixel(), KisPainter::q, SELECTION_ADD, KisScanlineFill::setCloseGap(), KisScanlineFill::setOpacitySpread(), KisScanlineFill::setThreshold(), and KisDefaultBoundsBase::wrapAroundMode().

selectRegionsFromContourUntilColor() [1/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContourUntilColor	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		const KoColor &	color ) const

Definition at line 1013 of file KisEncloseAndFillPainter.cpp.

{
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    selectRegionsFromContourUntilColor(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice, color);
}

selectRegionsFromContourUntilColor() [2/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContourUntilColor	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QVector< QPoint > &	enclosingPoints,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		const KoColor &	color ) const

Definition at line 1023 of file KisEncloseAndFillPainter.cpp.

{
    if (enclosingPoints.isEmpty()) {
        return;
    }
    const QRect inclusionRect = q->device()->defaultBounds()->wrapAroundMode()
                                ? enclosingMaskRect
                                : imageRect;
    // Here we just fill all the areas from the border towards inside until the specific color
    for (const QPoint &point : enclosingPoints) {
        if (!inclusionRect.contains(point)) {
            continue;
        }
        // Continue if the region under the point was already filled
        if (*(resultMask->pixel(point).data()) == MAX_SELECTED) {
            continue;
        }
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
        KisScanlineFill gc(referenceDevice, point, inclusionRect);
        gc.setThreshold(q->fillThreshold());
        gc.setOpacitySpread(q->opacitySpread());
        gc.setCloseGap(q->closeGap());
        // Use the enclosing mask as boundary so that we don't fill
        // potentially large regions in the outside
        gc.fillSelectionUntilColor(mask, color, enclosingMask);
        resultMask->applySelection(mask, SELECTION_ADD);
    }
}

References KisPixelSelection::applySelection(), KisPaintDevice::defaultBounds(), KisPainter::device, KisScanlineFill::fillSelectionUntilColor(), MAX_SELECTED, KisPaintDevice::pixel(), KisPainter::q, SELECTION_ADD, KisScanlineFill::setCloseGap(), KisScanlineFill::setOpacitySpread(), KisScanlineFill::setThreshold(), and KisDefaultBoundsBase::wrapAroundMode().

selectRegionsFromContourUntilColorOrTransparent() [1/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContourUntilColorOrTransparent	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		const KoColor &	color ) const

Definition at line 1057 of file KisEncloseAndFillPainter.cpp.

{
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    selectRegionsFromContourUntilColorOrTransparent(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice, color);
}

selectRegionsFromContourUntilColorOrTransparent() [2/2]

void KisEncloseAndFillPainter::Private::selectRegionsFromContourUntilColorOrTransparent	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QVector< QPoint > &	enclosingPoints,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		const KoColor &	color ) const

Definition at line 1067 of file KisEncloseAndFillPainter.cpp.

{
    if (enclosingPoints.isEmpty()) {
        return;
    }
    const QRect inclusionRect = q->device()->defaultBounds()->wrapAroundMode()
                                ? enclosingMaskRect
                                : imageRect;
    // Here we just fill all the areas from the border towards inside until the specific color
    for (const QPoint &point : enclosingPoints) {
        if (!inclusionRect.contains(point)) {
            continue;
        }
        // Continue if the region under the point was already filled
        if (*(resultMask->pixel(point).data()) == MAX_SELECTED) {
            continue;
        }
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
        KisScanlineFill gc(referenceDevice, point, inclusionRect);
        gc.setThreshold(q->fillThreshold());
        gc.setOpacitySpread(q->opacitySpread());
        gc.setCloseGap(q->closeGap());
        // Use the enclosing mask as boundary so that we don't fill
        // potentially large regions in the outside
        gc.fillSelectionUntilColorOrTransparent(mask, color, enclosingMask);
        resultMask->applySelection(mask, SELECTION_ADD);
    }
}

References KisPixelSelection::applySelection(), KisPaintDevice::defaultBounds(), KisPainter::device, KisScanlineFill::fillSelectionUntilColorOrTransparent(), MAX_SELECTED, KisPaintDevice::pixel(), KisPainter::q, SELECTION_ADD, KisScanlineFill::setCloseGap(), KisScanlineFill::setOpacitySpread(), KisScanlineFill::setThreshold(), and KisDefaultBoundsBase::wrapAroundMode().

selectRegionsSurroundedBySpecificColor()

void KisEncloseAndFillPainter::Private::selectRegionsSurroundedBySpecificColor	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 695 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<SpecificColorDifferencePolicy> policy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectRegionsSurroundedBySpecificColorGeneric()

template<typename SelectionPolicy >

void KisEncloseAndFillPainter::Private::selectRegionsSurroundedBySpecificColorGeneric	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		SelectionPolicy	selectionPolicy,
		bool	colorOrTransparent = false ) const

Definition at line 749 of file KisEncloseAndFillPainter.cpp.

{
    // Get the enclosing mask contour points
    const QVector<QPoint> enclosingPoints = getEnclosingContourPoints(enclosingMask, enclosingMaskRect);
    if (enclosingPoints.isEmpty()) {
        return;
    }
    // Here we just fill all the areas from the border towards inside until the
    // specific color. This selects any region that touches the enclosing area
    // contour and that is not equal to the surrounding color
    if (colorOrTransparent) {
        selectRegionsFromContourUntilColorOrTransparent(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice, selectionPolicy.color);
    } else {
        selectRegionsFromContourUntilColor(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice, selectionPolicy.color);
    }
    // Invert the mask since it contains the regions surrounding the regions we
    // want, that is, the regions that touch the enclosing area contour and that
    // are not equal to the surrounding color. We want the opposite
    invertMaskRect(resultMask, enclosingMaskRect);
    // Since, after inverting, the mask includes the region outside the enclosing
    // mask, we must intersect the current mask with the enclosing mask. The result
    // is a mask that includes all the closed regions inside the enclosing mask
    resultMask->applySelection(enclosingMask, SELECTION_INTERSECT);
    
    if (regionSelectionIncludeSurroundingRegions) {
        // Remove the regions that touch the enclosing area
        removeContourRegions(resultMask, enclosingMask, enclosingPoints, enclosingMaskRect, referenceDevice);
    } else {
        // Remove the surrounding regions. Also there shouldn't be any regions
        // that touch the enclosing area contour after this step
        KisPixelSelectionSP mask = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
        selectSimilarRegions(mask, enclosingMask, enclosingMaskRect, referenceDevice, selectionPolicy);
        resultMask->applySelection(mask, SELECTION_SUBTRACT);
    }
    if (resultMaskRect) {
        *resultMaskRect = resultMask->selectedExactRect();
    }
}

References KisPixelSelection::applySelection(), KisEncloseAndFillPainter::regionSelectionIncludeSurroundingRegions(), KisPixelSelection::selectedExactRect(), SELECTION_INTERSECT, and SELECTION_SUBTRACT.

selectRegionsSurroundedBySpecificColorOrTransparent()

void KisEncloseAndFillPainter::Private::selectRegionsSurroundedBySpecificColorOrTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 729 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    // Here we must compute the specific color and transparent masks separately
    KisPixelSelectionSP resultMaskTransparent = new KisPixelSelection(new KisSelectionDefaultBounds(resultMask));
    if (softness == 0) {
        HardSelectionPolicy<SpecificColorOrTransparentDifferencePolicy> colorPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold());
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, colorPolicy, true);
    } else {
        SoftSelectionPolicy<SpecificColorOrTransparentDifferencePolicy> colorPolicy(referenceDevice->colorSpace(), regionSelectionColor, q->fillThreshold(), softness);
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, colorPolicy, true);
    }
}

References KisPaintDevice::colorSpace(), KisPainter::q, and KisEncloseAndFillPainter::regionSelectionColor().

selectRegionsSurroundedByTransparent()

void KisEncloseAndFillPainter::Private::selectRegionsSurroundedByTransparent	(	KisPixelSelectionSP	resultMask,
		QRect *	resultMaskRect,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice ) const

Definition at line 712 of file KisEncloseAndFillPainter.cpp.

{
    using namespace KisEncloseAndFillPainterDetail;
    const int softness = 100 - q->opacitySpread();
    if (softness == 0) {
        HardSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), KoColor::createTransparent(referenceDevice->colorSpace()), q->fillThreshold());
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    } else {
        SoftSelectionPolicy<TransparentDifferencePolicy> policy(referenceDevice->colorSpace(), KoColor::createTransparent(referenceDevice->colorSpace()), q->fillThreshold(), softness);
        selectRegionsSurroundedBySpecificColorGeneric(resultMask, resultMaskRect, enclosingMask, enclosingMaskRect, referenceDevice, policy);
    }
}

References KisPaintDevice::colorSpace(), KoColor::createTransparent(), and KisPainter::q.

selectSimilarRegions()

template<typename SelectionPolicy >

int KisEncloseAndFillPainter::Private::selectSimilarRegions	(	KisPixelSelectionSP	resultMask,
		KisPixelSelectionSP	enclosingMask,
		const QRect &	enclosingMaskRect,
		KisPaintDeviceSP	referenceDevice,
		SelectionPolicy	selectionPolicy ) const

Definition at line 922 of file KisEncloseAndFillPainter.cpp.

{
    KisSequentialIterator resultMaskIterator(resultMask, enclosingMaskRect);
    KisSequentialConstIterator enclosingMaskIterator(enclosingMask, enclosingMaskRect);
    KisSequentialConstIterator referenceDeviceIterator(referenceDevice, enclosingMaskRect);
    int nPixels = 0;
    // Select all the pixels using the given selection policy
    while (resultMaskIterator.nextPixel() && enclosingMaskIterator.nextPixel() && referenceDeviceIterator.nextPixel()) {
        if (*enclosingMaskIterator.oldRawData() == MIN_SELECTED) {
            continue;
        }
        const quint8 selection = selectionPolicy.getSelectionFor(referenceDeviceIterator.oldRawData());
        if (selection > MIN_SELECTED) {
            *resultMaskIterator.rawData() = selection;
            ++nPixels;
        }
    }
    return nPixels;
}

References MIN_SELECTED, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisPainter::selection.

Member Data Documentation

imageRect

QRect KisEncloseAndFillPainter::Private::imageRect

Definition at line 135 of file KisEncloseAndFillPainter.cpp.

q

KisEncloseAndFillPainter* KisEncloseAndFillPainter::Private::q {nullptr}

Definition at line 129 of file KisEncloseAndFillPainter.cpp.

{nullptr};

regionSelectionColor

KoColor KisEncloseAndFillPainter::Private::regionSelectionColor

Definition at line 131 of file KisEncloseAndFillPainter.cpp.

regionSelectionIncludeContourRegions

bool KisEncloseAndFillPainter::Private::regionSelectionIncludeContourRegions {true}

Definition at line 133 of file KisEncloseAndFillPainter.cpp.

{true};

regionSelectionIncludeSurroundingRegions

bool KisEncloseAndFillPainter::Private::regionSelectionIncludeSurroundingRegions {true}

Definition at line 134 of file KisEncloseAndFillPainter.cpp.

{true};

regionSelectionInvert

bool KisEncloseAndFillPainter::Private::regionSelectionInvert {false}

Definition at line 132 of file KisEncloseAndFillPainter.cpp.

{false};

regionSelectionMethod

RegionSelectionMethod KisEncloseAndFillPainter::Private::regionSelectionMethod {SelectAllRegions}

Definition at line 130 of file KisEncloseAndFillPainter.cpp.

{SelectAllRegions};

---

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

• libs/image/KisEncloseAndFillPainter.cpp