KisPropagateColorsFilter.cpp File Reference

#include <cmath>
#include <filter/kis_filter_category_ids.h>
#include <KoUpdater.h>
#include <kis_filter_configuration.h>
#include <KisGlobalResourcesInterface.h>
#include <KisSequentialIteratorProgress.h>
#include <kis_processing_information.h>
#include <KoColorSpaceRegistry.h>
#include "KisPropagateColorsConfigWidget.h"
#include "KisPropagateColorsFilterConfiguration.h"
#include "KisPropagateColorsFilter.h"

Go to the source code of this file.

Classes
struct	GenericExpansionStrategy< DiagonalDistance, BoundedExpansion, ExpandAlpha >
struct	ScaledProgress

Functions
template<typename ExpansionStrategy >
void	expand (ExpansionStrategy &expansionStrategy, KoUpdater *progressUpdater)
template<quint32 DiagonalDistance>
void	selectStrategyAndExpand1 (KisPaintDeviceSP device, const QRect &applyRect, const KisPropagateColorsFilterConfiguration *filterConfig, KoUpdater *progressUpdater)
template<quint32 DiagonalDistance, bool BoundedExpansion>
void	selectStrategyAndExpand2 (KisPaintDeviceSP device, const QRect &applyRect, const KisPropagateColorsFilterConfiguration *filterConfig, KoUpdater *progressUpdater)
static void	swapRowPointers (quint8 **distanceMapRow1, quint8 **distanceMapRow2, quint8 **deviceRow1, quint8 **deviceRow2)

Function Documentation

expand()

template<typename ExpansionStrategy >

void expand	(	ExpansionStrategy &	expansionStrategy,
		KoUpdater *	progressUpdater )

Definition at line 226 of file KisPropagateColorsFilter.cpp.

{
    ScaledProgress progress(expansionStrategy.rect.height() * 2, progressUpdater);
 
    QVector<quint8> distanceMapRows(expansionStrategy.rect.width() * 4 * 2);
    QVector<quint8> deviceRows(expansionStrategy.rect.width() * expansionStrategy.sourceDevicePixelSize * 2);
    quint8 *distanceMapRow1, *distanceMapRow2;
    quint8 *deviceRow1, *deviceRow2;
 
    // Forwards pass
    distanceMapRow1 = distanceMapRows.data();
    distanceMapRow2 = distanceMapRows.data() + expansionStrategy.rect.width() * 4;
    deviceRow1 = deviceRows.data();
    deviceRow2 = deviceRows.data() + expansionStrategy.rect.width() * expansionStrategy.sourceDevicePixelSize;
    // Top row
    expansionStrategy.distanceMap->readBytes(distanceMapRow1, expansionStrategy.rect.left(),
                                             expansionStrategy.rect.top(), expansionStrategy.rect.width(), 1);
    expansionStrategy.sourceDevice->readBytes(deviceRow1, expansionStrategy.rect.left(),
                                              expansionStrategy.rect.top(), expansionStrategy.rect.width(), 1);
    // Left pixel
    expansionStrategy.initializePixel(reinterpret_cast<quint32*>(distanceMapRow1), deviceRow1);
    // Middle pixels
    {
        quint32 *distancePixel = reinterpret_cast<quint32*>(distanceMapRow1) + 1;
        quint8 *devicePixel = deviceRow1 + expansionStrategy.sourceDevicePixelSize;
        for (qint32 x = 1; x < expansionStrategy.rect.width();
                ++x, ++distancePixel, devicePixel += expansionStrategy.sourceDevicePixelSize) {
 
            expansionStrategy.initializePixel(distancePixel, devicePixel);
            if (*distancePixel == 0) {
                continue;
            }
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                distancePixel - 1, devicePixel - expansionStrategy.sourceDevicePixelSize,
                expansionStrategy.orthogonalDistance
            );
        }
    }
    expansionStrategy.distanceMap->writeBytes(distanceMapRow1, expansionStrategy.rect.left(),
                                              expansionStrategy.rect.top(), expansionStrategy.rect.width(), 1);
    expansionStrategy.sourceDevice->writeBytes(deviceRow1, expansionStrategy.rect.left(),
                                               expansionStrategy.rect.top(), expansionStrategy.rect.width(), 1);
    progress.stepUp();
    // Rest of rows
    for (qint32 y = expansionStrategy.rect.top() + 1; y <= expansionStrategy.rect.bottom(); ++y) {
        expansionStrategy.distanceMap->readBytes(distanceMapRow2, expansionStrategy.rect.left(),
                                                 y, expansionStrategy.rect.width(), 1);
        expansionStrategy.sourceDevice->readBytes(deviceRow2, expansionStrategy.rect.left(), y,
                                                  expansionStrategy.rect.width(), 1);
 
        quint32 *topDistancePixel = reinterpret_cast<quint32*>(distanceMapRow1);
        quint32 *distancePixel = reinterpret_cast<quint32*>(distanceMapRow2);
        quint8 *topDevicePixel = deviceRow1;
        quint8 *devicePixel = deviceRow2;
        // Left pixel
        {
            expansionStrategy.initializePixel(distancePixel, devicePixel);
            if (*distancePixel != 0) {
                if (expansionStrategy.rect.width() > 1) {
                    expansionStrategy.updatePixel(
                        distancePixel, devicePixel,
                        topDistancePixel, topDevicePixel,
                        topDistancePixel + 1, topDevicePixel + expansionStrategy.sourceDevicePixelSize,
                        expansionStrategy.orthogonalDistance, expansionStrategy.diagonalDistance
                    );
                } else {
                    expansionStrategy.updatePixel(
                        distancePixel, devicePixel,
                        topDistancePixel, topDevicePixel,
                        expansionStrategy.orthogonalDistance
                    );
                }
            }
            ++topDistancePixel;
            ++distancePixel;
            topDevicePixel += expansionStrategy.sourceDevicePixelSize;
            devicePixel += expansionStrategy.sourceDevicePixelSize;
        }
        // Middle pixels
        for (qint32 x = 1; x < expansionStrategy.rect.width() - 1;
                ++x, ++topDistancePixel, ++distancePixel,
                topDevicePixel += expansionStrategy.sourceDevicePixelSize,
                devicePixel += expansionStrategy.sourceDevicePixelSize) {
 
            expansionStrategy.initializePixel(distancePixel, devicePixel);
            if (*distancePixel == 0) {
                continue;
            }
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                topDistancePixel - 1,topDevicePixel - expansionStrategy.sourceDevicePixelSize,
                topDistancePixel, topDevicePixel,
                topDistancePixel + 1, topDevicePixel + expansionStrategy.sourceDevicePixelSize,
                distancePixel - 1, devicePixel - expansionStrategy.sourceDevicePixelSize,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance
            );
        }
        // Right pixel
        expansionStrategy.initializePixel(distancePixel, devicePixel);
        if (expansionStrategy.rect.width() > 1 && *distancePixel != 0) {
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                topDistancePixel - 1, topDevicePixel - expansionStrategy.sourceDevicePixelSize,
                distancePixel - 1, devicePixel - expansionStrategy.sourceDevicePixelSize,
                topDistancePixel, topDevicePixel,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance,
                expansionStrategy.orthogonalDistance
            );
        }
        // Write new pixels
        expansionStrategy.distanceMap->writeBytes(distanceMapRow2, expansionStrategy.rect.left(),
                                                  y, expansionStrategy.rect.width(), 1);
        expansionStrategy.sourceDevice->writeBytes(deviceRow2, expansionStrategy.rect.left(),
                                                   y, expansionStrategy.rect.width(), 1);
        // Swap pointers
        swapRowPointers(&distanceMapRow1, &distanceMapRow2, &deviceRow1, &deviceRow2);
 
        progress.stepUp();
    }
 
    // Backwards pass
    // Bottom row
    // Right pixel (no op)
    // Middle pixels
    {
        quint32 *distancePixel = reinterpret_cast<quint32*>(distanceMapRow1) + expansionStrategy.rect.width() - 2;
        quint8 *devicePixel =
            deviceRow1 + expansionStrategy.sourceDevicePixelSize * (expansionStrategy.rect.width() - 2);
        for (qint32 x = 1; x < expansionStrategy.rect.width();
                ++x, --distancePixel, devicePixel -= expansionStrategy.sourceDevicePixelSize) {
 
            if (*distancePixel == 0) {
                continue;
            }
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                distancePixel + 1, devicePixel + expansionStrategy.sourceDevicePixelSize,
                expansionStrategy.orthogonalDistance
            );
        }
    }
    expansionStrategy.distanceMap->writeBytes(distanceMapRow1, expansionStrategy.rect.left(),
                                              expansionStrategy.rect.bottom(), expansionStrategy.rect.width(), 1);
    expansionStrategy.sourceDevice->writeBytes(deviceRow1, expansionStrategy.rect.left(),
                                               expansionStrategy.rect.bottom(), expansionStrategy.rect.width(), 1);
    progress.stepUp();
    // Rest of rows
    for (qint32 y = expansionStrategy.rect.bottom() - 1; y >= expansionStrategy.rect.top(); --y) {
        expansionStrategy.distanceMap->readBytes(distanceMapRow2, expansionStrategy.rect.left(),
                                                 y, expansionStrategy.rect.width(), 1);
        expansionStrategy.sourceDevice->readBytes(deviceRow2, expansionStrategy.rect.left(),
                                                  y, expansionStrategy.rect.width(), 1);
 
        quint32 *bottomDistancePixel =
            reinterpret_cast<quint32*>(distanceMapRow1) + expansionStrategy.rect.width() - 1;
        quint32 *distancePixel =
            reinterpret_cast<quint32*>(distanceMapRow2) + expansionStrategy.rect.width() - 1;
        quint8 *bottomDevicePixel =
            deviceRow1 + expansionStrategy.sourceDevicePixelSize * (expansionStrategy.rect.width() - 1);
        quint8 *devicePixel =
            deviceRow2 + expansionStrategy.sourceDevicePixelSize * (expansionStrategy.rect.width() - 1);
        // Right pixel
        {
            if (*distancePixel != 0) {
                if (expansionStrategy.rect.width() > 1) {
                    expansionStrategy.updatePixel(
                        distancePixel, devicePixel,
                        bottomDistancePixel, bottomDevicePixel,
                        bottomDistancePixel - 1, bottomDevicePixel - expansionStrategy.sourceDevicePixelSize,
                        expansionStrategy.orthogonalDistance, expansionStrategy.diagonalDistance
                    );
                } else {
                    expansionStrategy.updatePixel(
                        distancePixel, devicePixel,
                        bottomDistancePixel, bottomDevicePixel,
                        expansionStrategy.orthogonalDistance
                    );
                }
            }
            --bottomDistancePixel;
            --distancePixel;
            bottomDevicePixel -= expansionStrategy.sourceDevicePixelSize;
            devicePixel -= expansionStrategy.sourceDevicePixelSize;
        }
        // Middle pixels
        for (qint32 x = 1; x < expansionStrategy.rect.width() - 1;
                ++x, --bottomDistancePixel, --distancePixel,
                bottomDevicePixel -= expansionStrategy.sourceDevicePixelSize,
                devicePixel -= expansionStrategy.sourceDevicePixelSize) {
 
            if (*distancePixel == 0) {
                continue;
            }
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                bottomDistancePixel + 1, bottomDevicePixel + expansionStrategy.sourceDevicePixelSize,
                bottomDistancePixel, bottomDevicePixel,
                bottomDistancePixel - 1, bottomDevicePixel - expansionStrategy.sourceDevicePixelSize,
                distancePixel + 1, devicePixel + expansionStrategy.sourceDevicePixelSize,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance
            );
        }
        // Left pixel
        if (expansionStrategy.rect.width() > 1 && *distancePixel != 0) {
            expansionStrategy.updatePixel(
                distancePixel, devicePixel,
                bottomDistancePixel + 1, bottomDevicePixel + expansionStrategy.sourceDevicePixelSize,
                bottomDistancePixel, bottomDevicePixel,
                distancePixel + 1, devicePixel + expansionStrategy.sourceDevicePixelSize,
                expansionStrategy.diagonalDistance, expansionStrategy.orthogonalDistance,
                expansionStrategy.orthogonalDistance
            );
        }
        // Write new pixels
        expansionStrategy.distanceMap->writeBytes(distanceMapRow2, expansionStrategy.rect.left(),
                                                  y, expansionStrategy.rect.width(), 1);
        expansionStrategy.sourceDevice->writeBytes(deviceRow2, expansionStrategy.rect.left(), y,
                                                   expansionStrategy.rect.width(), 1);
        // Swap pointers
        swapRowPointers(&distanceMapRow1, &distanceMapRow2, &deviceRow1, &deviceRow2);
 
        progress.stepUp();
    }
 
    progress.complete();
}

References ScaledProgress::complete(), ScaledProgress::stepUp(), and swapRowPointers().

selectStrategyAndExpand1()

template<quint32 DiagonalDistance>

void selectStrategyAndExpand1	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisPropagateColorsFilterConfiguration *	filterConfig,
		KoUpdater *	progressUpdater )

Definition at line 478 of file KisPropagateColorsFilter.cpp.

{
    const KisPropagateColorsFilterConfiguration::ExpansionMode expansionMode = filterConfig->expansionMode();
    
    if (expansionMode == KisPropagateColorsFilterConfiguration::ExpansionMode_Bounded) {
        selectStrategyAndExpand2<DiagonalDistance, true>(device, applyRect, filterConfig, progressUpdater);
    } else {
        selectStrategyAndExpand2<DiagonalDistance, false>(device, applyRect, filterConfig, progressUpdater);
    }
}

References KisPropagateColorsFilterConfiguration::expansionMode(), and KisPropagateColorsFilterConfiguration::ExpansionMode_Bounded.

selectStrategyAndExpand2()

template<quint32 DiagonalDistance, bool BoundedExpansion>

void selectStrategyAndExpand2	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisPropagateColorsFilterConfiguration *	filterConfig,
		KoUpdater *	progressUpdater )

Definition at line 457 of file KisPropagateColorsFilter.cpp.

{
    const KisPropagateColorsFilterConfiguration::AlphaChannelMode alphaChannelMode = filterConfig->alphaChannelMode();
    
    if (alphaChannelMode == KisPropagateColorsFilterConfiguration::AlphaChannelMode_Preserve) {
        GenericExpansionStrategy<DiagonalDistance, BoundedExpansion, false> expansionStrategy(
            device, applyRect, filterConfig->expansionAmount()
        );
        expand(expansionStrategy, progressUpdater);
    } else {
        GenericExpansionStrategy<DiagonalDistance, BoundedExpansion, true> expansionStrategy(
            device, applyRect, filterConfig->expansionAmount()
        );
        expand(expansionStrategy, progressUpdater);
    }
}

References KisPropagateColorsFilterConfiguration::alphaChannelMode(), KisPropagateColorsFilterConfiguration::AlphaChannelMode_Preserve, expand(), and KisPropagateColorsFilterConfiguration::expansionAmount().

swapRowPointers()

static void swapRowPointers ( quint8 ** distanceMapRow1, quint8 ** distanceMapRow2, quint8 ** deviceRow1, quint8 ** deviceRow2 )

static

Definition at line 185 of file KisPropagateColorsFilter.cpp.

{
    quint8 *temp = *distanceMapRow1;
    *distanceMapRow1 = *distanceMapRow2;
    *distanceMapRow2 = temp;
    temp = *deviceRow1;
    *deviceRow1 = *deviceRow2;
    *deviceRow2 = temp;
}