#include <palettize.h>

Inheritance diagram for KisFilterPalettize:

Public Types
enum	AlphaMode { Clip , Index , Dither }

enum	ColorMode { PerChannelOffset , NearestColors }

enum	Colorspace { Lab , RGB }

enum	PatternValueMode { Auto , Lightness , Alpha }

enum	ThresholdMode { Pattern , Noise }

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

	KisFilterPalettize ()

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 ()

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 42 of file palettize.h.

Member Enumeration Documentation

◆ AlphaMode

enum KisFilterPalettize::AlphaMode

Enumerator
Clip
Index
Dither

Definition at line 49 of file palettize.h.

                   {
        Clip,
        Index,
        Dither
    };

◆ ColorMode

enum KisFilterPalettize::ColorMode

Enumerator
PerChannelOffset
NearestColors

Definition at line 63 of file palettize.h.

                   {
        PerChannelOffset,
        NearestColors
    };

◆ Colorspace

enum KisFilterPalettize::Colorspace

Enumerator
Lab
RGB

Definition at line 45 of file palettize.h.

◆ PatternValueMode

enum KisFilterPalettize::PatternValueMode

Enumerator
Auto
Lightness
Alpha

Definition at line 58 of file palettize.h.

                          {
        Auto,
        Lightness,
        Alpha
    };

◆ ThresholdMode

enum KisFilterPalettize::ThresholdMode

Enumerator
Pattern
Noise

Definition at line 54 of file palettize.h.

                       {
        Pattern,
        Noise
    };

Constructor & Destructor Documentation

◆ KisFilterPalettize()

KisFilterPalettize::KisFilterPalettize ( )

Definition at line 190 of file palettize.cpp.

                                       : KisFilter(id(), FiltersCategoryMapId, i18n("&Palettize..."))
{
    setColorSpaceIndependence(FULLY_INDEPENDENT);
    setSupportsPainting(true);
    setShowConfigurationWidget(true);
}

References FULLY_INDEPENDENT, KisBaseProcessor::setColorSpaceIndependence(), KisBaseProcessor::setShowConfigurationWidget(), and KisBaseProcessor::setSupportsPainting().

Member Function Documentation

◆ createConfigurationWidget()

KisConfigWidget * KisFilterPalettize::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 178 of file palettize.cpp.

{
    Q_UNUSED(dev);
    Q_UNUSED(useForMasks);
 
    return new KisPalettizeWidget(parent);
}

◆ defaultConfiguration()

KisFilterConfigurationSP KisFilterPalettize::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 203 of file palettize.cpp.

{
    KisFilterConfigurationSP config = factoryConfiguration(resourcesInterface);
 
    config->setProperty("palette", "Default");
    config->setProperty("colorspace", Colorspace::Lab);
    config->setProperty("ditherEnabled", false);
    KisDitherWidget::factoryConfiguration(*config, "dither/");
    config->setProperty("dither/colorMode", ColorMode::PerChannelOffset);
    config->setProperty("dither/offsetScale", 0.125);
    config->setProperty("alphaEnabled", true);
    config->setProperty("alphaMode", AlphaMode::Clip);
    config->setProperty("alphaClip", 0.5);
    config->setProperty("alphaIndex", 0);
    KisDitherWidget::factoryConfiguration(*config, "alphaDither/");
 
    return config;
}

References Clip, KisDitherWidget::factoryConfiguration(), factoryConfiguration(), Lab, and PerChannelOffset.

◆ factoryConfiguration()

KisFilterConfigurationSP KisFilterPalettize::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 197 of file palettize.cpp.

{
    return new KisFilterPalettizeConfiguration("palettize", 1, resourcesInterface);
}

◆ id()

static KoID KisFilterPalettize::id ( )

inlinestatic

Definition at line 68 of file palettize.h.

68{ return KoID("palettize", i18n("Palettize")); }

KoID

Definition KoID.h:30

◆ processImpl()

void KisFilterPalettize::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 222 of file palettize.cpp.

{
    const KisFilterPalettizeConfiguration *config = dynamic_cast<const KisFilterPalettizeConfiguration*>(_config.data());
    KIS_SAFE_ASSERT_RECOVER_RETURN(config);
    KIS_SAFE_ASSERT_RECOVER_NOOP(config->hasLocalResourcesSnapshot());
 
    const KoColorSetSP palette = config->palette();
 
    const int searchColorspace = config->getInt("colorspace");
    const bool ditherEnabled = config->getBool("ditherEnabled");
    const int colorMode = config->getInt("dither/colorMode");
    const double offsetScale = config->getDouble("dither/offsetScale");
    const bool alphaEnabled = config->getBool("alphaEnabled");
    const int alphaMode = config->getInt("alphaMode");
    const double alphaClip = config->getDouble("alphaClip");
    const int alphaIndex = config->getInt("alphaIndex");
 
    const KoColorSpace* colorspace = device->colorSpace();
    const KoColorSpace* workColorspace = (searchColorspace == Colorspace::Lab
                                              ? KoColorSpaceRegistry::instance()->lab16()
                                              : KoColorSpaceRegistry::instance()->rgb16("sRGB-elle-V2-srgbtrc.icc"));
 
    const quint8 colorCount = ditherEnabled && colorMode == ColorMode::NearestColors ? 2 : 1;
 
    using SearchColor = boost::geometry::model::point<quint16, 3, boost::geometry::cs::cartesian>;
    struct ColorCandidate {
        KoColor color;
        quint16 index;
        double distance;
    };
    using SearchEntry = std::pair<SearchColor, ColorCandidate>;
    boost::geometry::index::rtree<SearchEntry, boost::geometry::index::quadratic<16>> rtree;
 
    if (palette) {
        // Add palette colors to search tree
        quint16 index = 0;
        for (int row = 0; row < palette->rowCount(); ++row) {
            for (int column = 0; column < palette->columnCount(); ++column) {
                KisSwatch swatch = palette->getColorGlobal(column, row);
                if (swatch.isValid()) {
                    KoColor color = swatch.color().convertedTo(colorspace);
                    KoColor workColor = swatch.color().convertedTo(workColorspace);
                    SearchColor searchColor;
                    memcpy(&searchColor, workColor.data(), sizeof(SearchColor));
                    // Don't add duplicates so won't dither between identical colors
                    std::vector<SearchEntry> result;
                    rtree.query(boost::geometry::index::contains(searchColor), std::back_inserter(result));
                    if (result.empty()) rtree.insert(SearchEntry(searchColor, {color, index, 0.0}));
                }
                ++index;
            }
        }
 
        KisDitherUtil ditherUtil;
        if (ditherEnabled) ditherUtil.setConfiguration(*config, "dither/");
 
        KisDitherUtil alphaDitherUtil;
        if (alphaMode == AlphaMode::Dither) alphaDitherUtil.setConfiguration(*config, "alphaDither/");
 
        KisSequentialIteratorProgress pixel(device, applyRect, progressUpdater);
        while (pixel.nextPixel()) {
            KoColor workColor(pixel.oldRawData(), colorspace);
            workColor.convertTo(workColorspace);
 
            // Find dither threshold
            double threshold = 0.5;
            if (ditherEnabled) {
                threshold = ditherUtil.threshold(QPoint(pixel.x(), pixel.y()));
 
                // Traditional per-channel ordered dithering
                if (colorMode == ColorMode::PerChannelOffset) {
                    QVector<float> normalized(int(workColorspace->channelCount()));
                    workColorspace->normalisedChannelsValue(workColor.data(), normalized);
                    for (int channel = 0; channel < int(workColorspace->channelCount()); ++channel) {
                        normalized[channel] += (threshold - 0.5) * offsetScale;
                    }
                    workColorspace->fromNormalisedChannelsValue(workColor.data(), normalized);
                }
            }
 
            // Get candidate colors and their distances
            SearchColor searchColor;
            memcpy(reinterpret_cast<quint8 *>(&searchColor), workColor.data(), sizeof(SearchColor));
            std::vector<ColorCandidate> candidateColors;
            candidateColors.reserve(size_t(colorCount));
            double distanceSum = 0.0;
            for (auto it = rtree.qbegin(boost::geometry::index::nearest(searchColor, colorCount)); it != rtree.qend() && candidateColors.size() < colorCount; ++it) {
                ColorCandidate candidate = it->second;
                candidate.distance = boost::geometry::distance(searchColor, it->first);
                candidateColors.push_back(candidate);
                distanceSum += candidate.distance;
            }
 
            // Select color candidate
            quint16 selected;
            if (ditherEnabled && colorMode == ColorMode::NearestColors) {
                // Sort candidates by palette order for stable dither color ordering
                const bool swap = candidateColors[0].index > candidateColors[1].index;
                selected = swap ^ (candidateColors[swap].distance / distanceSum > threshold);
            }
            else {
                selected = 0;
            }
            ColorCandidate &candidate = candidateColors[selected];
 
            // Set alpha
            const double oldAlpha = colorspace->opacityF(pixel.oldRawData());
            double newAlpha = oldAlpha;
            if (alphaEnabled && !(!ditherEnabled && alphaMode == AlphaMode::Dither)) {
                if (alphaMode == AlphaMode::Clip) {
                    newAlpha = oldAlpha < alphaClip? 0.0 : 1.0;
                }
                else if (alphaMode == AlphaMode::Index) {
                    newAlpha = (candidate.index == alphaIndex ? 0.0 : 1.0);
                }
                else if (alphaMode == AlphaMode::Dither) {
                    newAlpha = oldAlpha < alphaDitherUtil.threshold(QPoint(pixel.x(), pixel.y())) ? 0.0 : 1.0;
                }
            }
            colorspace->setOpacity(candidate.color.data(), newAlpha, 1);
 
            // Copy color to pixel
            memcpy(pixel.rawData(), candidate.color.data(), colorspace->pixelSize());
        }
    }
}

References KoColorSpace::channelCount(), Clip, KisSwatch::color(), KisPaintDevice::colorSpace(), KoColor::convertedTo(), KoColor::convertTo(), KisSharedPtr< T >::data(), KoColor::data(), distance(), Dither, KoColorSpace::fromNormalisedChannelsValue(), KisPropertiesConfiguration::getBool(), KisPropertiesConfiguration::getDouble(), KisPropertiesConfiguration::getInt(), KisFilterConfiguration::hasLocalResourcesSnapshot(), Index, KoColorSpaceRegistry::instance(), KisSwatch::isValid(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, Lab, KoColorSpaceRegistry::lab16(), NearestColors, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::normalisedChannelsValue(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisFilterPalettizeConfiguration::palette(), palette, PerChannelOffset, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KoColorSpaceRegistry::rgb16(), KisDitherUtil::setConfiguration(), KisDitherUtil::threshold(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

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

plugins/filters/palettize/palettize.h
plugins/filters/palettize/palettize.cpp

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ AlphaMode

◆ ColorMode

◆ Colorspace

◆ PatternValueMode

◆ ThresholdMode

Constructor & Destructor Documentation

◆ KisFilterPalettize()

Member Function Documentation

◆ createConfigurationWidget()

◆ defaultConfiguration()

◆ factoryConfiguration()

◆ id()

◆ processImpl()