KisScreentoneGenerator Class Reference

#include <KisScreentoneGenerator.h>

Inheritance diagram for KisScreentoneGenerator:

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
virtual void	generate (KisProcessingInformation dst, const QSize &size, const KisFilterConfigurationSP config) const
virtual void	generate (KisProcessingInformation dst, const QSize &size, const KisFilterConfigurationSP config, KoUpdater *progressUpdater) const override
virtual void	generate (KisProcessingInformation dst, const QSize &size, const KisFilterConfigurationSP config, KoUpdater *progressUpdater) const=0
void	generate (KisProcessingInformation dst, const QSize &size, const KisScreentoneGeneratorConfigurationSP config, KoUpdater *progressUpdater) const
template<class Sampler >
void	generate (KisProcessingInformation dst, const QSize &size, const KisScreentoneGeneratorConfigurationSP config, KoUpdater *progressUpdater, const Sampler &sampler) const
template<class Sampler , class PostprocessingFunction >
void	generate (KisProcessingInformation dst, const QSize &size, const KisScreentoneGeneratorConfigurationSP config, KoUpdater *progressUpdater, const Sampler &sampler, const PostprocessingFunction &postprocessingFunction) const
	KisScreentoneGenerator ()
Public Member Functions inherited from KisGenerator
virtual bool	allowsSplittingIntoPatches () const
virtual QRect	generatedRect (QRect _imageArea, const KisFilterConfigurationSP=0) const
	KisGenerator (const KoID &id, const KoID &category, const QString &entry)
	~KisGenerator () 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

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 KisGenerator
QString	configEntryGroup () const
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 19 of file KisScreentoneGenerator.h.

Constructor & Destructor Documentation

KisScreentoneGenerator()

KisScreentoneGenerator::KisScreentoneGenerator

(

)

Definition at line 30 of file KisScreentoneGenerator.cpp.

                                               : KisGenerator(id(), KoID("basic"), i18n("&Screentone..."))
{
    setSupportsPainting(true);
}

References KisBaseProcessor::setSupportsPainting().

Member Function Documentation

checkUpdaterInterruptedAndSetPercent()

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

private

Definition at line 271 of file KisScreentoneGenerator.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 * KisScreentoneGenerator::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 375 of file KisScreentoneGenerator.cpp.

{
    Q_UNUSED(dev);
    return new KisScreentoneConfigWidget(parent);
}

defaultConfiguration()

KisFilterConfigurationSP KisScreentoneGenerator::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 367 of file KisScreentoneGenerator.cpp.

{
    KisScreentoneGeneratorConfigurationSP config = 
        dynamic_cast<KisScreentoneGeneratorConfiguration*>(factoryConfiguration(resourcesInterface).data());
    config->setDefaults();
    return config;
}

References KisSharedPtr< T >::data(), and factoryConfiguration().

factoryConfiguration()

KisFilterConfigurationSP KisScreentoneGenerator::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 362 of file KisScreentoneGenerator.cpp.

{
    return new KisScreentoneGeneratorConfiguration(resourcesInterface);
}

generate() [1/6]

void KisGenerator::generate ( KisProcessingInformation dst, const QSize & size, const KisFilterConfigurationSP config ) const

virtual

Provided for convenience when no progress reporting is needed.

Reimplemented from KisGenerator.

Definition at line 59 of file kis_generator.cpp.

{
    generate(dst, size, config, 0);
}

generate() [2/6]

void KisScreentoneGenerator::generate ( KisProcessingInformation dst, const QSize & size, const KisFilterConfigurationSP config, KoUpdater * progressUpdater ) const

overridevirtual

Override this function with the implementation of your generator.

Parameters

dst	the destination paint device
size	the size of the area that is to be filled
config	the parameters of the filter
progressUpdater	the progress updater

Implements KisGenerator.

Definition at line 35 of file KisScreentoneGenerator.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(config);
 
    const KisScreentoneGeneratorConfigurationSP generatorConfiguration =
        dynamic_cast<KisScreentoneGeneratorConfiguration*>(
            const_cast<KisFilterConfiguration*>(config.data())
        );
 
    return generate(dst, size, generatorConfiguration, progressUpdater);
}

References KisSharedPtr< T >::data(), generate(), and KIS_SAFE_ASSERT_RECOVER_RETURN.

generate() [3/6]

virtual void KisGenerator::generate ( KisProcessingInformation dst, const QSize & size, const KisFilterConfigurationSP config, KoUpdater * progressUpdater ) const

virtual

Override this function with the implementation of your generator.

Parameters

dst	the destination paint device
size	the size of the area that is to be filled
config	the parameters of the filter
progressUpdater	the progress updater

Implements KisGenerator.

generate() [4/6]

void KisScreentoneGenerator::generate	(	KisProcessingInformation	dst,
		const QSize &	size,
		const KisScreentoneGeneratorConfigurationSP	config,
		KoUpdater *	progressUpdater ) const

Definition at line 50 of file KisScreentoneGenerator.cpp.

{
    const int equalizationMode = config->equalizationMode();
 
    if (equalizationMode == KisScreentoneEqualizationMode_TemplateBased) {
        const KisScreentoneGeneratorTemplate &t = config->getTemplate();
        if (config->alignToPixelGrid()) {
            KisScreentoneGeneratorAlignedTemplateSampler<KisScreentoneGeneratorTemplate> sampler(t);
            generate(dst, size, config, progressUpdater, sampler);
        } else {
            KisScreentoneGeneratorUnAlignedTemplateSampler<KisScreentoneGeneratorTemplate> sampler(t);
            generate(dst, size, config, progressUpdater, sampler);
        }
        return;
    }
 
    const int pattern = config->pattern();
    const int shape = config->shape();
    const int interpolation = config->interpolation();
 
    {
        using namespace KisScreentoneScreentoneFunctions;
 
        if (pattern == KisScreentonePatternType_Dots) {
            if (shape == KisScreentoneShapeType_RoundDots) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsRoundLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsRoundLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsRoundSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsRoundSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_EllipseDotsLegacy) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseLinearEqualized_Legacy> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseLinear_Legacy> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseSinusoidalEqualized_Legacy> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseSinusoidal_Legacy> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_EllipseDots) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<DotsEllipseSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_DiamondDots) {
                if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                    KisScreentoneGeneratorFunctionSampler<DotsDiamondEqualized> sampler(config);
                    generate(dst, size, config, progressUpdater, sampler);
                } else {
                    KisScreentoneGeneratorFunctionSampler<DotsDiamond> sampler(config);
                    generate(dst, size, config, progressUpdater, sampler);
                }
            } else if (shape == KisScreentoneShapeType_SquareDots) {
                if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                    KisScreentoneGeneratorFunctionSampler<DotsSquareEqualized> sampler(config);
                    generate(dst, size, config, progressUpdater, sampler);
                } else {
                    KisScreentoneGeneratorFunctionSampler<DotsSquare> sampler(config);
                    generate(dst, size, config, progressUpdater, sampler);
                }
            }
        } else if (pattern == KisScreentonePatternType_Lines) {
            if (shape == KisScreentoneShapeType_StraightLines) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesStraightLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesStraightLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesStraightSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesStraightSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_SineWaveLines) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesSineWaveLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesSineWaveLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesSineWaveSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesSineWaveSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_TriangularWaveLines) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesTriangularWaveLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesTriangularWaveLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesTriangularWaveSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesTriangularWaveSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_SawtoothWaveLines) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesSawToothWaveLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesSawToothWaveLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesSawToothWaveSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesSawToothWaveSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            } else if (shape == KisScreentoneShapeType_CurtainsLines) {
                if (interpolation == KisScreentoneInterpolationType_Linear) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesCurtainsLinearEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesCurtainsLinear> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                } else if (interpolation == KisScreentoneInterpolationType_Sinusoidal) {
                    if (equalizationMode == KisScreentoneEqualizationMode_FunctionBased) {
                        KisScreentoneGeneratorFunctionSampler<LinesCurtainsSinusoidalEqualized> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    } else {
                        KisScreentoneGeneratorFunctionSampler<LinesCurtainsSinusoidal> sampler(config);
                        generate(dst, size, config, progressUpdater, sampler);
                    }
                }
            }
        }
    }
}

References generate(), KisScreentoneEqualizationMode_FunctionBased, KisScreentoneEqualizationMode_TemplateBased, KisScreentoneInterpolationType_Linear, KisScreentoneInterpolationType_Sinusoidal, KisScreentonePatternType_Dots, KisScreentonePatternType_Lines, KisScreentoneShapeType_CurtainsLines, KisScreentoneShapeType_DiamondDots, KisScreentoneShapeType_EllipseDots, KisScreentoneShapeType_EllipseDotsLegacy, KisScreentoneShapeType_RoundDots, KisScreentoneShapeType_SawtoothWaveLines, KisScreentoneShapeType_SineWaveLines, KisScreentoneShapeType_SquareDots, KisScreentoneShapeType_StraightLines, and KisScreentoneShapeType_TriangularWaveLines.

generate() [5/6]

template<class Sampler >

void KisScreentoneGenerator::generate	(	KisProcessingInformation	dst,
		const QSize &	size,
		const KisScreentoneGeneratorConfigurationSP	config,
		KoUpdater *	progressUpdater,
		const Sampler &	sampler ) const

Definition at line 245 of file KisScreentoneGenerator.cpp.

{
    const qreal contrast = config->contrast() / 50.0 - 1.0;
    const bool useThresholdFunction = qFuzzyCompare(contrast, 1.0);
 
    if (useThresholdFunction) {
        const qreal brightness = config->brightness() / 100.0;
        KisScreentoneBrightnessContrastFunctions::Threshold thresholdFunction(1.0 - brightness);
        generate(dst, size, config, progressUpdater, sampler, thresholdFunction);
    } else {
        const qreal brightness = config->brightness() / 50.0 - 1.0;
        const bool bypassBrightnessContrast = qFuzzyIsNull(brightness) && qFuzzyIsNull(contrast);
        if (bypassBrightnessContrast) {
            KisScreentoneBrightnessContrastFunctions::Identity brightnessContrastFunction;
            generate(dst, size, config, progressUpdater, sampler, brightnessContrastFunction);
        } else {
            KisScreentoneBrightnessContrastFunctions::BrightnessContrast brightnessContrastFunction(brightness, contrast);
            generate(dst, size, config, progressUpdater, sampler, brightnessContrastFunction);
        }
    }
}

References generate(), qFuzzyCompare(), and qFuzzyIsNull().

generate() [6/6]

template<class Sampler , class PostprocessingFunction >

void KisScreentoneGenerator::generate	(	KisProcessingInformation	dst,
		const QSize &	size,
		const KisScreentoneGeneratorConfigurationSP	config,
		KoUpdater *	progressUpdater,
		const Sampler &	sampler,
		const PostprocessingFunction &	postprocessingFunction ) const

Definition at line 288 of file KisScreentoneGenerator.cpp.

{
    KisPaintDeviceSP device = dst.paintDevice();
    Q_ASSERT(!device.isNull());
    KIS_SAFE_ASSERT_RECOVER_RETURN(config);
 
    checkUpdaterInterruptedAndSetPercent(progressUpdater, 0);
    
    const QRect bounds = QRect(dst.topLeft(), size);
    const KoColorSpace *colorSpace;
    if (device->colorSpace()->profile()->isLinear()) {
        colorSpace = KoColorSpaceRegistry::instance()->rgb8();
    } else {
        colorSpace = device->colorSpace();
    }
    
    KoColor foregroundColor = config->foregroundColor();
    KoColor backgroundColor = config->backgroundColor();
    qreal foregroundOpacity = config->foregroundOpacity() / 100.0;
    qreal backgroundOpacity = config->backgroundOpacity() / 100.0;
    foregroundColor.convertTo(colorSpace);
    backgroundColor.convertTo(colorSpace);
    foregroundColor.setOpacity(foregroundOpacity);
    backgroundColor.setOpacity(backgroundOpacity);
 
    KisPaintDeviceSP foregroundDevice = new KisPaintDevice(colorSpace, "screentone_generator_foreground_paint_device");
    KisPaintDeviceSP backgroundDevice;
    if (device->colorSpace()->profile()->isLinear()) {
        backgroundDevice = new KisPaintDevice(colorSpace, "screentone_generator_background_paint_device");
    } else {
        backgroundDevice = device;
    }
 
    foregroundDevice->fill(bounds, foregroundColor);
    checkUpdaterInterruptedAndSetPercent(progressUpdater, 25);
    backgroundDevice->fill(bounds, backgroundColor);
    checkUpdaterInterruptedAndSetPercent(progressUpdater, 50);
 
    KisSelectionSP selection = new KisSelection(device->defaultBounds(), KisImageResolutionProxy::identity());
    KisSequentialIterator it(selection->pixelSelection(), bounds);
 
    if (!config->invert()) {
        while (it.nextPixel()) {
            qreal v = std::round(sampler(it.x(), it.y()) * 10000.0) / 10000.0;
            v = qBound(0.0, postprocessingFunction(v), 1.0);
            *it.rawData() = 255 - static_cast<quint8>(qRound(v * 255.0));
        }
    } else {
        while (it.nextPixel()) {
            qreal v = std::round(sampler(it.x(), it.y()) * 10000.0) / 10000.0;
            v = qBound(0.0, postprocessingFunction(v), 1.0);
            *it.rawData() = static_cast<quint8>(qRound(v * 255.0));
        }
    }
    checkUpdaterInterruptedAndSetPercent(progressUpdater, 25);
 
    {
        KisPainter gc(backgroundDevice, selection);
        gc.setCompositeOpId(COMPOSITE_OVER);
        gc.bitBlt(bounds.topLeft(), foregroundDevice, bounds);
    }
    if (device->colorSpace()->profile()->isLinear()) {
        KisPainter gc(device);
        gc.setCompositeOpId(COMPOSITE_COPY);
        gc.bitBlt(bounds.topLeft(), backgroundDevice, bounds);
    }
    checkUpdaterInterruptedAndSetPercent(progressUpdater, 100);
}

References KisPainter::bitBlt(), bounds, checkUpdaterInterruptedAndSetPercent(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, COMPOSITE_OVER, KoColor::convertTo(), KisPaintDevice::defaultBounds(), KisPaintDevice::fill(), KisImageResolutionProxy::identity(), KoColorSpaceRegistry::instance(), KoColorProfile::isLinear(), KisSharedPtr< T >::isNull(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisProcessingInformation::paintDevice(), KisSelection::pixelSelection, KoColorSpace::profile(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KoColorSpaceRegistry::rgb8(), KisPainter::setCompositeOpId(), KoColor::setOpacity(), KisConstProcessingInformation::topLeft, v, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

id()

static KoID KisScreentoneGenerator::id ( )

inlinestatic

Definition at line 51 of file KisScreentoneGenerator.h.

                            {
        return KoID(KisScreentoneGeneratorConfiguration::defaultName(), i18n("Screentone"));
    }

References KisScreentoneGeneratorConfiguration::defaultName().

---

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

• plugins/generators/screentone/KisScreentoneGenerator.h
• plugins/generators/screentone/KisScreentoneGenerator.cpp