#include <KisHalftoneFilter.h>

Inheritance diagram for KisHalftoneFilter:

Public Member Functions
KisConfigWidget *	createConfigurationWidget (QWidget *parent, const KisPaintDeviceSP dev, bool useForMasks) const override

KisFilterConfigurationSP	defaultConfiguration (KisResourcesInterfaceSP resourcesInterface) const override

KisFilterConfigurationSP	factoryConfiguration (KisResourcesInterfaceSP resourcesInterface) const override

	KisHalftoneFilter ()

void	processImpl (KisPaintDeviceSP device, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater) const override

Public Member Functions inherited from KisFilter
virtual QRect	changedRect (const QRect &rect, const KisFilterConfigurationSP config, int lod) const

virtual bool	configurationAllowedForMask (KisFilterConfigurationSP config) const

virtual void	fixLoadedFilterConfigurationForMasks (KisFilterConfigurationSP config) const

	KisFilter (const KoID &id, const KoID &category, const QString &entry)

virtual QRect	neededRect (const QRect &rect, const KisFilterConfigurationSP config, int lod) const

virtual bool	needsTransparentPixels (const KisFilterConfigurationSP config, const KoColorSpace *cs) const

void	process (const KisPaintDeviceSP src, KisPaintDeviceSP dst, KisSelectionSP selection, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater=0) const

void	process (KisPaintDeviceSP device, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater=0) const

virtual bool	supportsLevelOfDetail (const KisFilterConfigurationSP config, int lod) const

	~KisFilter () override

Public Member Functions inherited from KisBaseProcessor
KisBookmarkedConfigurationManager *	bookmarkManager ()

const KisBookmarkedConfigurationManager *	bookmarkManager () const

ColorSpaceIndependence	colorSpaceIndependence () const

QString	id () const

	KisBaseProcessor (const KoID &id, const KoID &category, const QString &entry)

KoID	menuCategory () const

QString	menuEntry () const

QString	name () const

	Private ()

QKeySequence	shortcut () const

bool	showConfigurationWidget ()
	If true, the filter wants to show a configuration widget.

bool	supportsAdjustmentLayers () const
	This filter can be used in adjustment layers.

bool	supportsPainting () const

bool	supportsThreading () const

virtual	~KisBaseProcessor ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static KoID	id ()

Private Member Functions
bool	checkUpdaterInterruptedAndSetPercent (KoUpdater *progressUpdater, int percent) const

KisPaintDeviceSP	makeGeneratorPaintDevice (KisPaintDeviceSP prototype, const QString &prefix, const QRect &applyRect, const KisHalftoneFilterConfiguration config, KoUpdater progressUpdater) const

void	processAlpha (KisPaintDeviceSP device, const QRect &applyRect, const KisHalftoneFilterConfiguration config, KoUpdater progressUpdater) const

template<typename ChannelType >
void	processChannel (KisPaintDeviceSP device, KisPaintDeviceSP generatorDevice, const QRect &applyRect, const KisHalftoneFilterConfiguration config, const QString &prefix, KoChannelInfo channelInfo) const

void	processChannels (KisPaintDeviceSP device, const QRect &applyRect, const KisHalftoneFilterConfiguration config, KoUpdater progressUpdater) const

void	processIntensity (KisPaintDeviceSP device, const QRect &applyRect, const KisHalftoneFilterConfiguration config, KoUpdater progressUpdater) const

void	processMask (KisPaintDeviceSP device, const QRect &applyRect, const KisHalftoneFilterConfiguration config, KoUpdater progressUpdater) const

Static Private Member Functions
static QVector< quint8 >	makeHardnessLut (qreal hardness)

static QVector< quint8 >	makeNoiseWeightLut (qreal hardness)

static quint8	mapU8ToRange (quint8 value, quint8 new_min, quint8 new_max)

template<typename T >
static T	mapU8ToRange (quint8 value, T new_min, T new_max)

Private Attributes
KisCachedPaintDevice	m_genericDevicesCache

KisCachedPaintDevice	m_grayDevicesCache

KisCachedSelection	m_selectionsCache

Additional Inherited Members
Public Attributes inherited from KisBaseProcessor
KisBookmarkedConfigurationManager *	bookmarkManager

KoID	category

ColorSpaceIndependence	colorSpaceIndependence

QString	entry

KoID	id

QKeySequence	shortcut

bool	showConfigurationWidget

bool	supportsAdjustmentLayers

bool	supportsPainting

bool	supportsThreading

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Member Functions inherited from KisFilter
QString	configEntryGroup () const

void	setSupportsLevelOfDetail (bool value)

Protected Member Functions inherited from KisBaseProcessor
void	init (const QString &configEntryGroup)

void	setColorSpaceIndependence (ColorSpaceIndependence v)

void	setShortcut (const QKeySequence &shortcut)

void	setShowConfigurationWidget (bool v)

void	setSupportsAdjustmentLayers (bool v)

void	setSupportsPainting (bool v)

void	setSupportsThreading (bool v)

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Detailed Description

Definition at line 31 of file KisHalftoneFilter.h.

Constructor & Destructor Documentation

◆ KisHalftoneFilter()

KisHalftoneFilter::KisHalftoneFilter ( )

Definition at line 42 of file KisHalftoneFilter.cpp.

    : KisFilter(id(), FiltersCategoryArtisticId, i18n("&Halftone..."))
{
    setSupportsPainting(true);
}

References KisBaseProcessor::setSupportsPainting().

Member Function Documentation

◆ checkUpdaterInterruptedAndSetPercent()

bool KisHalftoneFilter::checkUpdaterInterruptedAndSetPercent	(	KoUpdater *	progressUpdater,
		int	percent ) const

private

Definition at line 173 of file KisHalftoneFilter.cpp.

{
    // The updater is null so return false to keep going
    // with the computations
    if (!progressUpdater) {
        return false;
    }
 
    if (progressUpdater->interrupted()) {
        return true;
    }
 
    progressUpdater->setProgress(percent);
    return false;
}

References KoUpdater::interrupted(), and KoUpdater::setProgress().

◆ createConfigurationWidget()

KisConfigWidget * KisHalftoneFilter::createConfigurationWidget	(	QWidget *	parent,
		const KisPaintDeviceSP	dev,
		bool	useForMasks ) const

overridevirtual

Create the configuration widget for this processor.

Parameters

parent	the Qt owner widget of this widget
dev	the paintdevice this filter will act on
useForMasks	shown if the filer is going to be used in a mask. Some filters may provide limited options when applied as a mask (e.g. Gaussian Blur)

Reimplemented from KisBaseProcessor.

Definition at line 706 of file KisHalftoneFilter.cpp.

{
    Q_UNUSED(useForMasks);
    return new KisHalftoneConfigWidget(parent, dev);
}

◆ defaultConfiguration()

KisFilterConfigurationSP KisHalftoneFilter::defaultConfiguration ( KisResourcesInterfaceSP resourcesInterface ) const

overridevirtual

Return the configuration set as the default by the user or the default configuration from the filter writer as returned by factoryConfiguration.

This configuration is used by default for the configuration widget and given to the process function if there is no configuration widget.

Returns: the default configuration of this widget

Reimplemented from KisBaseProcessor.

Definition at line 628 of file KisHalftoneFilter.cpp.

{
    KisHalftoneFilterConfigurationSP filterConfig =
        dynamic_cast<KisHalftoneFilterConfiguration*>(factoryConfiguration(resourcesInterface).data());
        
    filterConfig->setMode(KisHalftoneFilterConfiguration::defaultMode());
 
    QString defaultGeneratorId = KisHalftoneFilterConfiguration::defaultGeneratorId();
    KisGeneratorSP defaultGenerator = KisGeneratorRegistry::instance()->get(defaultGeneratorId);
 
    // intensity
    filterConfig->setGeneratorId("intensity_", defaultGeneratorId);
    if (defaultGenerator) {
        KisFilterConfigurationSP defaultGeneratorConfiguration =
            defaultGenerator->defaultConfiguration(resourcesInterface);
        if (defaultGeneratorId == "screentone") {
            defaultGeneratorConfiguration->setProperty("rotation", 45.0);
            defaultGeneratorConfiguration->setProperty("contrast", 50.0);
        }
        filterConfig->setGeneratorConfiguration("intensity_", defaultGeneratorConfiguration);
    }
    filterConfig->setHardness("intensity_", KisHalftoneFilterConfiguration::defaultHardness());
    filterConfig->setInvert("intensity_", KisHalftoneFilterConfiguration::defaultInvert());
    filterConfig->setForegroundColor("intensity_", KisHalftoneFilterConfiguration::defaultForegroundColor());
    filterConfig->setForegroundOpacity("intensity_", KisHalftoneFilterConfiguration::defaultForegroundOpacity());
    filterConfig->setBackgroundColor("intensity_", KisHalftoneFilterConfiguration::defaultBackgroundColor());
    filterConfig->setBackgroundOpacity("intensity_", KisHalftoneFilterConfiguration::defaultBackgroundOpacity());
    
    // Alpha
    filterConfig->setGeneratorId("alpha_", defaultGeneratorId);
    if (defaultGenerator) {
        KisFilterConfigurationSP defaultGeneratorConfiguration =
            defaultGenerator->defaultConfiguration(resourcesInterface);
        if (defaultGeneratorId == "screentone") {
            defaultGeneratorConfiguration->setProperty("rotation", 45.0);
            defaultGeneratorConfiguration->setProperty("contrast", 50.0);
        }
        filterConfig->setGeneratorConfiguration("alpha_", defaultGeneratorConfiguration);
    }
    filterConfig->setHardness("alpha_", KisHalftoneFilterConfiguration::defaultHardness());
    filterConfig->setInvert("alpha_", KisHalftoneFilterConfiguration::defaultInvert());
 
    // The channels only use default generator if it is screentone
    // because there are predefined ways of presenting the patterns (screen angles)
 
    // Map channel prefixes to rotation angle
    QHash<QString, qreal> channelDict;
    channelDict.insert("RGBA_channel0_", 15.0);
    channelDict.insert("RGBA_channel1_", 45.0);
    channelDict.insert("RGBA_channel2_", 75.0);
    channelDict.insert("CMYKA_channel0_", 15.0);
    channelDict.insert("CMYKA_channel1_", 75.0);
    channelDict.insert("CMYKA_channel2_", 0.0);
    channelDict.insert("CMYKA_channel3_", 45.0);
 
    for (auto i = channelDict.constBegin(); i != channelDict.constEnd(); ++i) {
        if (defaultGenerator && defaultGeneratorId == "screentone") {
            filterConfig->setGeneratorId(i.key(), "screentone");
            KisFilterConfigurationSP defaultGeneratorConfiguration =
                defaultGenerator->defaultConfiguration(resourcesInterface);
            defaultGeneratorConfiguration->setProperty("rotation", i.value());
            defaultGeneratorConfiguration->setProperty("contrast", 50.0);
            filterConfig->setGeneratorConfiguration(i.key(), defaultGeneratorConfiguration);
        } else {
            filterConfig->setGeneratorId(i.key(), "");
        }
        filterConfig->setHardness(i.key(), KisHalftoneFilterConfiguration::defaultHardness());
        filterConfig->setInvert(i.key(), KisHalftoneFilterConfiguration::defaultInvert());
    }
    
    return filterConfig;
}

◆ factoryConfiguration()

KisFilterConfigurationSP KisHalftoneFilter::factoryConfiguration ( KisResourcesInterfaceSP resourcesInterface ) const

overridevirtual

Returns: the default configuration object as defined by whoever wrote the plugin. This object must be filled in with fromXML after that.

Reimplemented from KisBaseProcessor.

Definition at line 701 of file KisHalftoneFilter.cpp.

{
    return new KisHalftoneFilterConfiguration("halftone", 1, resourcesInterface);
}

◆ id()

static KoID KisHalftoneFilter::id ( )

inlinestatic

Definition at line 36 of file KisHalftoneFilter.h.

                            {
        return KoID("halftone", i18n("Halftone"));
    }

◆ makeGeneratorPaintDevice()

KisPaintDeviceSP KisHalftoneFilter::makeGeneratorPaintDevice	(	KisPaintDeviceSP	prototype,
		const QString &	prefix,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		KoUpdater *	progressUpdater ) const

private

Definition at line 142 of file KisHalftoneFilter.cpp.

{
    const QString generatorId = config->generatorId(prefix);
    if (generatorId.isEmpty()) {
        return nullptr;
    }
 
    KisGeneratorSP generator  = KisGeneratorRegistry::instance()->get(generatorId);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(generator, nullptr);
 
    KisFilterConfigurationSP generatorConfiguration = config->generatorConfiguration(prefix);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(generatorConfiguration, nullptr);
 
    // Fill the generator device
    KisPaintDeviceSP generatorDevice = m_grayDevicesCache.getDevice(prototype, KoColorSpaceRegistry::instance()->graya8());
 
    KisProcessingInformation(generatorDevice, applyRect.topLeft(), KisSelectionSP());
    generator->generate(
        KisProcessingInformation(generatorDevice, applyRect.topLeft(),KisSelectionSP()),
        applyRect.size(),
        generatorConfiguration,
        progressUpdater
    );
 
    return generatorDevice;
}

References KisGenerator::generate(), KisHalftoneFilterConfiguration::generatorConfiguration(), KisHalftoneFilterConfiguration::generatorId(), KoGenericRegistry< T >::get(), KisCachedPaintDevice::getDevice(), KisGeneratorRegistry::instance(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_grayDevicesCache.

◆ makeHardnessLut()

QVector< quint8 > KisHalftoneFilter::makeHardnessLut ( qreal hardness )

staticprivate

Definition at line 113 of file KisHalftoneFilter.cpp.

{
    QVector<quint8> hardnessLut(256);
    if (qFuzzyCompare(hardness, 1.0)) {
        for (int i = 0; i < 256; ++i) {
            hardnessLut[i] = i < 128 ? 0 : 255;
        }
    } else {
        qreal m = 1.0 / (1.0 - hardness);
        qreal b = -m * (hardness / 2.0);
        for (int i = 0; i < 256; ++i) {
            hardnessLut[i] = qBound(0, static_cast<int>(qRound((m * (i / 255.0) + b) * 255.0)), 255);
        }
    }
    return hardnessLut;
}

References qFuzzyCompare().

◆ makeNoiseWeightLut()

QVector< quint8 > KisHalftoneFilter::makeNoiseWeightLut ( qreal hardness )

staticprivate

Definition at line 130 of file KisHalftoneFilter.cpp.

{
    QVector<quint8> noiseWeightLut(256);
    hardness *= 0.99;
    for (int i = 0; i < 256; ++i) {
        qreal iNorm = i / 255.0;
        qreal weight = (2.0 - std::abs(4.0 * iNorm - 2.0)) + hardness;
        noiseWeightLut[i] = qBound(0, static_cast<int>(qRound(weight * 255.0)), 255);
    }
    return noiseWeightLut;
}

◆ mapU8ToRange() [1/2]

static quint8 KisHalftoneFilter::mapU8ToRange	(	quint8	value,
		quint8	new_min,
		quint8	new_max )

inlinestaticprivate

Definition at line 57 of file KisHalftoneFilter.h.

                                                                                    {
        Q_UNUSED(new_min);
        Q_UNUSED(new_max);
        return value;
    }

References value().

◆ mapU8ToRange() [2/2]

template<typename T >

static T KisHalftoneFilter::mapU8ToRange	(	quint8	value,
		T	new_min,
		T	new_max )

inlinestaticprivate

Definition at line 63 of file KisHalftoneFilter.h.

                                                                     {
        return value * (new_max - new_min) / 255 + new_min;
    }

References value().

◆ processAlpha()

void KisHalftoneFilter::processAlpha	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		KoUpdater *	progressUpdater ) const

private

Definition at line 498 of file KisHalftoneFilter.cpp.

{
    const QString prefix = "alpha_";
    
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 0)) {
        return;
    }
 
    // Make the generator device
    KisPaintDeviceSP generatorDevice = makeGeneratorPaintDevice(device, prefix, applyRect, config, nullptr);
    if (!generatorDevice) {
        return;
    }
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 50)) {
        return;
    }
 
    // Make the hardness and the noise weight LUT
    const qreal hardness = config->hardness(prefix) / 100.0;
    const QVector<quint8> hardnessLut = makeHardnessLut(hardness);
    const QVector<quint8> noiseWeightLut = makeNoiseWeightLut(hardness);
 
    // Fill the device
    const bool invert = config->invert(prefix);
    KisSequentialIterator dstIterator(device, applyRect);
    KisSequentialIterator srcIterator(generatorDevice, applyRect);
 
    if (!invert) {
        while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
            int dst = 255 - device->colorSpace()->opacityU8(dstIterator.rawData());
            int src = srcIterator.rawData()[0];
            int srcAlpha = srcIterator.rawData()[1];
 
            // Combine pixels
            int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
            // Apply hardness
            result = hardnessLut[result];
 
            device->colorSpace()->setOpacity(dstIterator.rawData(), static_cast<quint8>(255 - result), 1);
        }
    } else {
        while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
            int dst = device->colorSpace()->opacityU8(dstIterator.rawData());
            int src = srcIterator.rawData()[0];
            int srcAlpha = srcIterator.rawData()[1];
 
            // Combine pixels
            int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
            // Apply hardness
            result = hardnessLut[result];
 
            device->colorSpace()->setOpacity(dstIterator.rawData(), static_cast<quint8>(result), 1);
        }
    }
    m_grayDevicesCache.putDevice(generatorDevice);
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 100)) {
        return;
    }
}

References checkUpdaterInterruptedAndSetPercent(), KisPaintDevice::colorSpace(), KisHalftoneFilterConfiguration::hardness(), KisHalftoneFilterConfiguration::invert(), m_grayDevicesCache, makeGeneratorPaintDevice(), makeHardnessLut(), makeNoiseWeightLut(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KisCachedPaintDevice::putDevice(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KoColorSpace::setOpacity().

◆ processChannel()

template<typename ChannelType >

void KisHalftoneFilter::processChannel	(	KisPaintDeviceSP	device,
		KisPaintDeviceSP	generatorDevice,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		const QString &	prefix,
		KoChannelInfo *	channelInfo ) const

private

Definition at line 312 of file KisHalftoneFilter.cpp.

{
    const int channelPos = channelInfo->pos() / sizeof(ChannelType);
    // Make the hardness and the noise weight LUT
    const qreal hardness = config->hardness(prefix) / 100.0;
    const QVector<quint8> hardnessLut = makeHardnessLut(hardness);
    const QVector<quint8> noiseWeightLut = makeNoiseWeightLut(hardness);
 
    // Fill the device
    const bool invert = config->invert(prefix);
    KisSequentialIterator dstIterator(device, applyRect);
    KisSequentialIterator srcIterator(generatorDevice, applyRect);
 
    const KoColorSpace *colorSpace = device->colorSpace();
 
    if (colorSpace->profile()->isLinear()) {
        if (!invert) {
            while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dst = 255 - device->colorSpace()->scaleToU8(dstIterator.rawData(), channelPos);
                int src = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
                KoColor c(QColor(src, src, src, srcAlpha), device->colorSpace());
                src = device->colorSpace()->scaleToU8(c.data(), 0);
                srcAlpha = device->colorSpace()->scaleToU8(c.data(), device->colorSpace()->alphaPos());
 
                // Combine pixels
                int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                ChannelType *dstPixel = reinterpret_cast<ChannelType*>(dstIterator.rawData());
                ChannelType channelMin = static_cast<ChannelType>(channelInfo->getUIMin());
                ChannelType channelMax = static_cast<ChannelType>(channelInfo->getUIMax());
                dstPixel[channelPos] = static_cast<ChannelType>(mapU8ToRange(255 - result, channelMin, channelMax));
            }
        } else {
            while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dst = device->colorSpace()->scaleToU8(dstIterator.rawData(), channelPos);
                int src = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
                KoColor c(QColor(src, src, src, srcAlpha), device->colorSpace());
                src = device->colorSpace()->scaleToU8(c.data(), 0);
                srcAlpha = device->colorSpace()->scaleToU8(c.data(), device->colorSpace()->alphaPos());
 
                // Combine pixels
                int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                ChannelType *dstPixel = reinterpret_cast<ChannelType*>(dstIterator.rawData());
                ChannelType channelMin = static_cast<ChannelType>(channelInfo->getUIMin());
                ChannelType channelMax = static_cast<ChannelType>(channelInfo->getUIMax());
                dstPixel[channelPos] = static_cast<ChannelType>(mapU8ToRange(result, channelMin, channelMax));
            }
        }
    } else {
        if (!invert) {
            while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dst = 255 - device->colorSpace()->scaleToU8(dstIterator.rawData(), channelPos);
                int src = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
 
                // Combine pixels
                int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                ChannelType *dstPixel = reinterpret_cast<ChannelType*>(dstIterator.rawData());
                ChannelType channelMin = static_cast<ChannelType>(channelInfo->getUIMin());
                ChannelType channelMax = static_cast<ChannelType>(channelInfo->getUIMax());
                dstPixel[channelPos] = static_cast<ChannelType>(mapU8ToRange(255 - result, channelMin, channelMax));
            }
        } else {
            while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dst = device->colorSpace()->scaleToU8(dstIterator.rawData(), channelPos);
                int src = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
 
                // Combine pixels
                int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                ChannelType *dstPixel = reinterpret_cast<ChannelType*>(dstIterator.rawData());
                ChannelType channelMin = static_cast<ChannelType>(channelInfo->getUIMin());
                ChannelType channelMax = static_cast<ChannelType>(channelInfo->getUIMax());
                dstPixel[channelPos] = static_cast<ChannelType>(mapU8ToRange(result, channelMin, channelMax));
            }
        }
    }
}

References KoColorSpace::alphaPos(), KisPaintDevice::colorSpace(), KoColor::data(), KoChannelInfo::getUIMax(), KoChannelInfo::getUIMin(), KisHalftoneFilterConfiguration::hardness(), KisHalftoneFilterConfiguration::invert(), KoColorProfile::isLinear(), makeHardnessLut(), makeNoiseWeightLut(), mapU8ToRange(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoChannelInfo::pos(), KoColorSpace::profile(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KoColorSpace::scaleToU8().

◆ processChannels()

void KisHalftoneFilter::processChannels	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		KoUpdater *	progressUpdater ) const

private

Definition at line 413 of file KisHalftoneFilter.cpp.

{
    const QList<KoChannelInfo *> channels = device->colorSpace()->channels();
    const int progressStep = 100 / (channels.count() * 2);
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 0)) {
        return;
    }
 
    // Make the generator devices
    QVector<KisPaintDeviceSP> generatorDevices(channels.count());
    for (int i = 0; i < channels.count(); ++i) {
        if (channels.at(i)->channelType() == KoChannelInfo::ALPHA) {
            generatorDevices[i] = nullptr;
        } else {
            const QString prefix =
                device->colorSpace()->colorModelId().id() + "_channel" + QString::number(i) + "_";
            KisPaintDeviceSP generatorDevice = makeGeneratorPaintDevice(device, prefix, applyRect, config, nullptr);
            if (generatorDevice) {
                generatorDevices[i] = generatorDevice;
            } else {
                generatorDevices[i] = nullptr;
            }
        }
        if (checkUpdaterInterruptedAndSetPercent(progressUpdater, progressUpdater->progress() + progressStep)) {
            return;
        }
    }
 
    // process channels
    for (int i = 0; i < channels.count(); ++i) {
        if (!generatorDevices[i]) {
            progressUpdater->setProgress(progressUpdater->progress() + progressStep);
            continue;
        }
 
        const QString prefix = device->colorSpace()->colorModelId().id() + "_channel" + QString::number(i) + "_";
 
        switch (channels.at(i)->channelValueType()) {
        case KoChannelInfo::UINT8: {
            processChannel<quint8>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::UINT16: {
            processChannel<quint16>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::UINT32: {
            processChannel<quint32>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::FLOAT16: {
#ifdef HAVE_OPENEXR
            processChannel<half>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
#endif
            break;
        } case KoChannelInfo::FLOAT32: {
            processChannel<float>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::FLOAT64: {
            processChannel<double>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::INT8: {
            processChannel<qint8>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } case KoChannelInfo::INT16: {
            processChannel<qint16>(device, generatorDevices[i], applyRect, config, prefix, channels.at(i));
            break;
        } default: {
            break;
        }
        }
 
        m_grayDevicesCache.putDevice(generatorDevices[i]);
 
        if (checkUpdaterInterruptedAndSetPercent(progressUpdater, progressUpdater->progress() + progressStep)) {
            return;
        }
    }
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 100)) {
        return;
    }
}

References KoChannelInfo::ALPHA, KoColorSpace::channels, checkUpdaterInterruptedAndSetPercent(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoChannelInfo::FLOAT64, KoID::id(), KoChannelInfo::INT16, KoChannelInfo::INT8, m_grayDevicesCache, makeGeneratorPaintDevice(), KoUpdater::progress(), KisCachedPaintDevice::putDevice(), KoUpdater::setProgress(), KoChannelInfo::UINT16, KoChannelInfo::UINT32, and KoChannelInfo::UINT8.

◆ processImpl()

void KisHalftoneFilter::processImpl	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisFilterConfigurationSP	config,
		KoUpdater *	progressUpdater ) const

overridevirtual

Override this function with the implementation of your filter.

This is a low level function that expects all the conditions for the

Parameters

device	be met. Use usual process() methods instead.
device	the paint device to filter
applyRect	the rectangle where the filter is applied
config	the parameters of the filter
progressUpdater	to pass on the progress the filter is making

Implements KisFilter.

Definition at line 48 of file KisHalftoneFilter.cpp.

{
    const KisHalftoneFilterConfiguration *filterConfig =
            dynamic_cast<const KisHalftoneFilterConfiguration*>(config.data());
 
    Q_ASSERT(device);
    KIS_SAFE_ASSERT_RECOVER_RETURN(filterConfig);
    KIS_SAFE_ASSERT_RECOVER_NOOP(filterConfig->hasLocalResourcesSnapshot());
 
    const QString mode = filterConfig->mode();
    KIS_SAFE_ASSERT_RECOVER_RETURN(
        mode == KisHalftoneFilterConfiguration::HalftoneMode_Intensity ||
        mode == KisHalftoneFilterConfiguration::HalftoneMode_IndependentChannels ||
        mode == KisHalftoneFilterConfiguration::HalftoneMode_Alpha
    );
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(
        (device->colorSpace()->colorModelId().id() == AlphaColorModelID.id() &&
         mode == KisHalftoneFilterConfiguration::HalftoneMode_Alpha) ||
        (device->colorSpace()->colorModelId().id() == GrayColorModelID.id() &&
         mode == KisHalftoneFilterConfiguration::HalftoneMode_Intensity) ||
        (device->colorSpace()->colorModelId().id() == GrayAColorModelID.id() &&
         (mode == KisHalftoneFilterConfiguration::HalftoneMode_Intensity ||
          mode == KisHalftoneFilterConfiguration::HalftoneMode_Alpha)) ||
        ((device->colorSpace()->colorModelId().id() == RGBAColorModelID.id() ||
          device->colorSpace()->colorModelId().id() == XYZAColorModelID.id() ||
          device->colorSpace()->colorModelId().id() == LABAColorModelID.id() ||
          device->colorSpace()->colorModelId().id() == CMYKAColorModelID.id() ||
          device->colorSpace()->colorModelId().id() == YCbCrAColorModelID.id()) &&
         (mode == KisHalftoneFilterConfiguration::HalftoneMode_Intensity ||
          mode == KisHalftoneFilterConfiguration::HalftoneMode_IndependentChannels ||
          mode == KisHalftoneFilterConfiguration::HalftoneMode_Alpha))
    );
    
    if (mode == KisHalftoneFilterConfiguration::HalftoneMode_Intensity) {
        KIS_SAFE_ASSERT_RECOVER_RETURN(
            device->colorSpace()->colorModelId().id() != AlphaColorModelID.id()
        );
        processIntensity(device, applyRect, filterConfig, progressUpdater);
    } else if (mode == KisHalftoneFilterConfiguration::HalftoneMode_IndependentChannels) {
        KIS_SAFE_ASSERT_RECOVER_RETURN(
            device->colorSpace()->colorModelId().id() != AlphaColorModelID.id() &&
            device->colorSpace()->colorModelId().id() != GrayColorModelID.id() &&
            device->colorSpace()->colorModelId().id() != GrayAColorModelID.id()
        );
        processChannels(device, applyRect, filterConfig, progressUpdater);
    } else {
        KIS_SAFE_ASSERT_RECOVER_RETURN(
            device->colorSpace()->colorModelId().id() != GrayColorModelID.id()
        );
        if (filterConfig->colorModelId() == AlphaColorModelID.id())
        {
            // This an Alpha layer (mask layer) but the device passed
            // here has the composition color space (GrayA)
            processMask(device, applyRect, filterConfig, progressUpdater);
        } else {
            // process the alpha channel of a multichannel device
            processAlpha(device, applyRect, filterConfig, progressUpdater);
        }
    }
}

References AlphaColorModelID, CMYKAColorModelID, KisHalftoneFilterConfiguration::colorModelId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisSharedPtr< T >::data(), GrayAColorModelID, GrayColorModelID, KisHalftoneFilterConfiguration::HalftoneMode_Alpha, KisHalftoneFilterConfiguration::HalftoneMode_IndependentChannels, KisHalftoneFilterConfiguration::HalftoneMode_Intensity, KisFilterConfiguration::hasLocalResourcesSnapshot(), KoID::id(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, LABAColorModelID, KisHalftoneFilterConfiguration::mode(), processAlpha(), processChannels(), processIntensity(), processMask(), RGBAColorModelID, XYZAColorModelID, and YCbCrAColorModelID.

◆ processIntensity()

void KisHalftoneFilter::processIntensity	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		KoUpdater *	progressUpdater ) const

private

Definition at line 189 of file KisHalftoneFilter.cpp.

{
    const QString prefix = "intensity_";
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 0)) {
        return;
    }
    
    // Make the generator device
    KisPaintDeviceSP generatorDevice = makeGeneratorPaintDevice(device, prefix, applyRect, config, nullptr);
    if (!generatorDevice) {
        return;
    }
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 25)) {
        return;
    }
 
    // Make the hardness and the noise weight LUT
    const qreal hardness = config->hardness(prefix) / 100.0;
    const QVector<quint8> hardnessLut = makeHardnessLut(hardness);
    const QVector<quint8> noiseWeightLut = makeNoiseWeightLut(hardness);
 
    // Fill the mask device
    KisSelectionSP maskDevice = m_selectionsCache.getSelection();
 
    {
        const bool invert = config->invert(prefix);
 
        KisSequentialIterator maskIterator(maskDevice->pixelSelection(), applyRect);
        KisSequentialIterator dstIterator(device, applyRect);
        KisSequentialIterator srcIterator(generatorDevice, applyRect);
 
        if (!invert) {
            while (maskIterator.nextPixel() && dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dstGray = device->colorSpace()->intensity8(dstIterator.rawData());
                int srcGray = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
 
                // Combine pixels
                int result = qBound(0, dstGray + (srcGray - 128) * noiseWeightLut[dstGray] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                *maskIterator.rawData() = 255 - result;
            }
        } else {
            while (maskIterator.nextPixel() && dstIterator.nextPixel() && srcIterator.nextPixel()) {
                int dstGray = device->colorSpace()->intensity8(dstIterator.rawData());
                int srcGray = srcIterator.rawData()[0];
                int srcAlpha = srcIterator.rawData()[1];
 
                // Combine pixels
                int result = qBound(0, dstGray + (srcGray - 128) * noiseWeightLut[dstGray] * srcAlpha / 0xFE01, 255);
 
                // Apply hardness
                result = hardnessLut[result];
 
                *maskIterator.rawData() = result;
            }
        }
        m_grayDevicesCache.putDevice(generatorDevice);
    }
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 50)) {
        return;
    }
 
    // Make the halftone image
    const KoColorSpace *colorSpace;
    if (device->colorSpace()->profile()->isLinear()) {
        colorSpace = KoColorSpaceRegistry::instance()->rgb8();
    } else {
        colorSpace = device->colorSpace();
    }
    KisPaintDeviceSP halftoneDevice = m_genericDevicesCache.getDevice(device, colorSpace);
    
    {
        KisPaintDeviceSP foregroundDevice = m_genericDevicesCache.getDevice(device, colorSpace);
        KoColor foregroundColor = config->foregroundColor(prefix);
        KoColor backgroundColor = config->backgroundColor(prefix);
        const qreal foregroundOpacity = config->foregroundOpacity(prefix) / 100.0;
        const qreal backgroundOpacity = config->backgroundOpacity(prefix) / 100.0;
        foregroundColor.convertTo(colorSpace);
        backgroundColor.convertTo(colorSpace);
        foregroundColor.setOpacity(foregroundOpacity);
        backgroundColor.setOpacity(backgroundOpacity);
 
        foregroundDevice->fill(applyRect, foregroundColor);
        halftoneDevice->fill(applyRect, backgroundColor);
 
        KisPainter painter(halftoneDevice, maskDevice);
        painter.setCompositeOpId(COMPOSITE_OVER);
        painter.bitBlt(applyRect.topLeft(), foregroundDevice, applyRect);
 
        m_genericDevicesCache.putDevice(foregroundDevice);
        m_selectionsCache.putSelection(maskDevice);
    }
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 75)) {
        return;
    }
 
    // Make the final image
    {
        KisPainter painter(halftoneDevice);
        painter.setCompositeOpId(COMPOSITE_DESTINATION_IN);
        painter.bitBlt(applyRect.topLeft(), device, applyRect);
    }
    {
        KisPainter painter(device);
        painter.setCompositeOpId(COMPOSITE_COPY);
        painter.bitBlt(applyRect.topLeft(), halftoneDevice, applyRect);
    }
    m_genericDevicesCache.putDevice(halftoneDevice);
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 100)) {
        return;
    }
}

References KisHalftoneFilterConfiguration::backgroundColor(), KisHalftoneFilterConfiguration::backgroundOpacity(), KisPainter::bitBlt(), checkUpdaterInterruptedAndSetPercent(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, COMPOSITE_DESTINATION_IN, COMPOSITE_OVER, KoColor::convertTo(), KisPaintDevice::fill(), KisHalftoneFilterConfiguration::foregroundColor(), KisHalftoneFilterConfiguration::foregroundOpacity(), KisCachedPaintDevice::getDevice(), KisCachedSelection::getSelection(), KisHalftoneFilterConfiguration::hardness(), KoColorSpaceRegistry::instance(), KoColorSpace::intensity8(), KisHalftoneFilterConfiguration::invert(), KoColorProfile::isLinear(), m_genericDevicesCache, m_grayDevicesCache, m_selectionsCache, makeGeneratorPaintDevice(), makeHardnessLut(), makeNoiseWeightLut(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSelection::pixelSelection, KoColorSpace::profile(), KisCachedPaintDevice::putDevice(), KisCachedSelection::putSelection(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KoColorSpaceRegistry::rgb8(), KisPainter::setCompositeOpId(), and KoColor::setOpacity().

◆ processMask()

void KisHalftoneFilter::processMask	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisHalftoneFilterConfiguration *	config,
		KoUpdater *	progressUpdater ) const

private

Definition at line 564 of file KisHalftoneFilter.cpp.

{
    const QString prefix = "alpha_";
    
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 0)) {
        return;
    }
 
    // Make the generator device
    KisPaintDeviceSP generatorDevice = makeGeneratorPaintDevice(device, prefix, applyRect, config, nullptr);
    if (!generatorDevice) {
        return;
    }
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 50)) {
        return;
    }
 
    // Make the hardness and the noise weight LUT
    const qreal hardness = config->hardness(prefix) / 100.0;
    const QVector<quint8> hardnessLut = makeHardnessLut(hardness);
    const QVector<quint8> noiseWeightLut = makeNoiseWeightLut(hardness);
 
    // Fill the device
    const bool invert = config->invert(prefix);
    KisSequentialIterator dstIterator(device, applyRect);
    KisSequentialIterator srcIterator(generatorDevice, applyRect);
 
    if (!invert) {
        while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
            int dst = 255 - *dstIterator.rawData();
            int src = *srcIterator.rawData();
 
            // Combine pixels
            int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] / 0xFF, 255);
 
            // Apply hardness
            result = hardnessLut[result];
 
            *dstIterator.rawData() = static_cast<quint8>(255 - result);
        }
    } else {
        while (dstIterator.nextPixel() && srcIterator.nextPixel()) {
            int dst = *dstIterator.rawData();
            int src = *srcIterator.rawData();
 
            // Combine pixels
            int result = qBound(0, dst + (src - 128) * noiseWeightLut[dst] / 0xFF, 255);
 
            // Apply hardness
            result = hardnessLut[result];
 
            *dstIterator.rawData() =  static_cast<quint8>(result);
        }
    }
    m_grayDevicesCache.putDevice(generatorDevice);
 
    if (checkUpdaterInterruptedAndSetPercent(progressUpdater, 100)) {
        return;
    }
}

References checkUpdaterInterruptedAndSetPercent(), KisHalftoneFilterConfiguration::hardness(), KisHalftoneFilterConfiguration::invert(), m_grayDevicesCache, makeGeneratorPaintDevice(), makeHardnessLut(), makeNoiseWeightLut(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisCachedPaintDevice::putDevice(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

Member Data Documentation

◆ m_genericDevicesCache

KisCachedPaintDevice KisHalftoneFilter::m_genericDevicesCache

mutableprivate

Definition at line 52 of file KisHalftoneFilter.h.

◆ m_grayDevicesCache

KisCachedPaintDevice KisHalftoneFilter::m_grayDevicesCache

mutableprivate

Definition at line 51 of file KisHalftoneFilter.h.

◆ m_selectionsCache

KisCachedSelection KisHalftoneFilter::m_selectionsCache

mutableprivate

Definition at line 50 of file KisHalftoneFilter.h.

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

plugins/filters/halftone/KisHalftoneFilter.h
plugins/filters/halftone/KisHalftoneFilter.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisHalftoneFilter()

Member Function Documentation

◆ checkUpdaterInterruptedAndSetPercent()

◆ createConfigurationWidget()

◆ defaultConfiguration()

◆ factoryConfiguration()

◆ id()

◆ makeGeneratorPaintDevice()

◆ makeHardnessLut()

◆ makeNoiseWeightLut()

◆ mapU8ToRange() [1/2]

◆ mapU8ToRange() [2/2]

◆ processAlpha()

◆ processChannel()

◆ processChannels()

◆ processImpl()

◆ processIntensity()

◆ processMask()

Member Data Documentation

◆ m_genericDevicesCache

◆ m_grayDevicesCache

◆ m_selectionsCache