KisRainDropsFilter Class Reference

#include <kis_raindrops_filter.h>

Inheritance diagram for KisRainDropsFilter:

Public Member Functions
KisConfigWidget *	createConfigurationWidget (QWidget *parent, const KisPaintDeviceSP dev, bool useForMasks) const override
KisFilterConfigurationSP	defaultConfiguration (KisResourcesInterfaceSP resourcesInterface) const override
	KisRainDropsFilter ()
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
virtual KisFilterConfigurationSP	factoryConfiguration (KisResourcesInterfaceSP resourcesInterface) 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 **	CreateBoolArray (uint Columns, uint Rows) const
void	FreeBoolArray (bool **lpbArray, uint Columns) const
uchar	LimitValues (int ColorValue) 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 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 16 of file kis_raindrops_filter.h.

Constructor & Destructor Documentation

KisRainDropsFilter()

KisRainDropsFilter::KisRainDropsFilter

(

)

Definition at line 46 of file kis_raindrops_filter.cpp.

    : KisFilter(id(), FiltersCategoryArtisticId, i18n("&Raindrops..."))
{
    setSupportsPainting(false);
    setSupportsThreading(false);
    setSupportsAdjustmentLayers(false);
}

References KisBaseProcessor::setSupportsAdjustmentLayers(), KisBaseProcessor::setSupportsPainting(), and KisBaseProcessor::setSupportsThreading().

Member Function Documentation

CreateBoolArray()

bool ** KisRainDropsFilter::CreateBoolArray ( uint Columns, uint Rows ) const

private

Definition at line 340 of file kis_raindrops_filter.cpp.

{
    bool** lpbArray = 0;
    lpbArray = (bool**) malloc(Columns * sizeof(bool*));
 
    if (lpbArray == 0)
        return (0);
 
    for (uint i = 0; i < Columns; ++i) {
        lpbArray[i] = (bool*) malloc(Rows * sizeof(bool));
        if (lpbArray[i] == 0) {
            FreeBoolArray(lpbArray, Columns);
            return (0);
        }
    }
 
    return (lpbArray);
}

References FreeBoolArray().

createConfigurationWidget()

KisConfigWidget * KisRainDropsFilter::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 379 of file kis_raindrops_filter.cpp.

{
    vKisIntegerWidgetParam param;
    param.push_back(KisIntegerWidgetParam(1, 200, 80, i18n("Drop size"), "dropsize"));
    param.push_back(KisIntegerWidgetParam(1, 500, 80, i18n("Number of drops"), "number"));
    param.push_back(KisIntegerWidgetParam(1, 100, 30, i18n("Fish eyes"), "fishEyes"));
    KisMultiIntegerFilterWidget * w = new KisMultiIntegerFilterWidget(id().id(), parent, id().id(), param);
    w->setConfiguration(defaultConfiguration(KisGlobalResourcesInterface::instance()));
    return w;
}

References defaultConfiguration(), and KisGlobalResourcesInterface::instance().

defaultConfiguration()

KisFilterConfigurationSP KisRainDropsFilter::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 390 of file kis_raindrops_filter.cpp.

{
    KisFilterConfigurationSP config = factoryConfiguration(resourcesInterface);
    config->setProperty("dropsize", 80);
    config->setProperty("number", 80);
    config->setProperty("fishEyes", 30);
    config->setProperty("seed", QTime::currentTime().msec());
 
 
    return config;
}

References KisBaseProcessor::factoryConfiguration().

FreeBoolArray()

void KisRainDropsFilter::FreeBoolArray ( bool ** lpbArray, uint Columns ) const

private

Definition at line 324 of file kis_raindrops_filter.cpp.

{
    for (uint i = 0; i < Columns; ++i)
        free(lpbArray[i]);
 
    free(lpbArray);
}

id()

static KoID KisRainDropsFilter::id ( )

inlinestatic

Definition at line 26 of file kis_raindrops_filter.h.

                            {
        return KoID("raindrops", i18n("Raindrops"));
    }

LimitValues()

uchar KisRainDropsFilter::LimitValues ( int ColorValue ) const

private

Definition at line 370 of file kis_raindrops_filter.cpp.

{
    if (ColorValue > 255)        // MAX = 255
        ColorValue = 255;
    if (ColorValue < 0)          // MIN = 0
        ColorValue = 0;
    return ((uchar) ColorValue);
}

processImpl()

void KisRainDropsFilter::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

This case should be filtered out at the higher level, in KisFilter::process() or in KisFilterStrokeStrategy

Implements KisFilter.

Definition at line 74 of file kis_raindrops_filter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!applyRect.isEmpty());
 
    QPoint srcTopLeft = applyRect.topLeft();
    Q_ASSERT(device);
 
    //read the filter configuration values from the KisFilterConfiguration object
    quint32 DropSize = config->getInt("dropSize", 80);
    quint32 number = config->getInt("number", 80);
    quint32 fishEyes = config->getInt("fishEyes", 30);
    QRandomGenerator rng(config->getInt("seed"));
 
    if (fishEyes <= 0) fishEyes = 1;
 
    if (fishEyes > 100) fishEyes = 100;
 
    int Width = applyRect.width();
    int Height = applyRect.height();
 
    bool** BoolMatrix = CreateBoolArray(Width, Height);
 
    int       i, j, k, l, m, n;                 // loop variables
    int       Bright;                           // Bright value for shadows and highlights
    int       x, y;                             // center coordinates
    int       Counter = 0;                      // Counter (duh !)
    int       NewSize;                          // Size of current raindrop
    int       halfSize;                         // Half of the current raindrop
    int       Radius;                           // Maximum radius for raindrop
    int       BlurRadius;                       // Blur Radius
    int       BlurPixels;
 
    double    r, a;                             // polar coordinates
    double    OldRadius;                        // Radius before processing
    double    NewfishEyes = (double)fishEyes * 0.01;  // FishEye Coefficients
    double    s;
    double    R, G, B;
 
    bool      FindAnother = false;              // To search for good coordinates
 
    const KoColorSpace * cs = device->colorSpace();
 
    // Init boolean Matrix.
 
    for (i = 0 ; i < Width; ++i) {
        for (j = 0 ; j < Height; ++j) {
            BoolMatrix[i][j] = false;
        }
    }
 
    progressUpdater->setRange(0, number);
    KisRandomAccessorSP dstAccessor = device->createRandomAccessorNG();
    
    for (uint NumBlurs = 0; NumBlurs <= number; ++NumBlurs) {
        NewSize = 5 + static_cast<int>(rng.bounded(1.0) * (DropSize - 5));
        halfSize = NewSize / 2;
        Radius = halfSize;
        s = Radius / log(NewfishEyes * Radius + 1);
 
        Counter = 0;
 
        do {
            FindAnother = false;
            y = static_cast<int>(rng.bounded(static_cast<double>(Width - 1)));
            x = static_cast<int>(rng.bounded(static_cast<double>(Height - 1)));
 
            if (BoolMatrix[y][x])
                FindAnother = true;
            else
                for (i = x - halfSize ; i <= x + halfSize; i++)
                    for (j = y - halfSize ; j <= y + halfSize; j++)
                        if ((i >= 0) && (i < Height) && (j >= 0) && (j < Width))
                            if (BoolMatrix[j][i])
                                FindAnother = true;
 
            Counter++;
        } while (FindAnother && Counter < 10000);
 
        if (Counter >= 10000) {
            NumBlurs = number;
            break;
        }
 
        for (i = -1 * halfSize ; i < NewSize - halfSize; i++) {
            for (j = -1 * halfSize ; j < NewSize - halfSize; j++) {
                r = sqrt((double)i * i + j * j);
                a = atan2(static_cast<double>(i), static_cast<double>(j));
 
                if (r <= Radius) {
                    OldRadius = r;
                    r = (exp(r / s) - 1) / NewfishEyes;
 
                    k = x + (int)(r * sin(a));
                    l = y + (int)(r * cos(a));
 
                    m = x + i;
                    n = y + j;
 
                    if ((k >= 0) && (k < Height) && (l >= 0) && (l < Width)) {
                        if ((m >= 0) && (m < Height) && (n >= 0) && (n < Width)) {
                            Bright = 0;
 
                            if (OldRadius >= 0.9 * Radius) {
                                if ((a <= 0) && (a > -2.25))
                                    Bright = -80;
                                else if ((a <= -2.25) && (a > -2.5))
                                    Bright = -40;
                                else if ((a <= 0.25) && (a > 0))
                                    Bright = -40;
                            }
 
                            else if (OldRadius >= 0.8 * Radius) {
                                if ((a <= -0.75) && (a > -1.50))
                                    Bright = -40;
                                else if ((a <= 0.10) && (a > -0.75))
                                    Bright = -30;
                                else if ((a <= -1.50) && (a > -2.35))
                                    Bright = -30;
                            }
 
                            else if (OldRadius >= 0.7 * Radius) {
                                if ((a <= -0.10) && (a > -2.0))
                                    Bright = -20;
                                else if ((a <= 2.50) && (a > 1.90))
                                    Bright = 60;
                            }
 
                            else if (OldRadius >= 0.6 * Radius) {
                                if ((a <= -0.50) && (a > -1.75))
                                    Bright = -20;
                                else if ((a <= 0) && (a > -0.25))
                                    Bright = 20;
                                else if ((a <= -2.0) && (a > -2.25))
                                    Bright = 20;
                            }
 
                            else if (OldRadius >= 0.5 * Radius) {
                                if ((a <= -0.25) && (a > -0.50))
                                    Bright = 30;
                                else if ((a <= -1.75) && (a > -2.0))
                                    Bright = 30;
                            }
 
                            else if (OldRadius >= 0.4 * Radius) {
                                if ((a <= -0.5) && (a > -1.75))
                                    Bright = 40;
                            }
 
                            else if (OldRadius >= 0.3 * Radius) {
                                if ((a <= 0) && (a > -2.25))
                                    Bright = 30;
                            }
 
                            else if (OldRadius >= 0.2 * Radius) {
                                if ((a <= -0.5) && (a > -1.75))
                                    Bright = 20;
                            }
 
                            BoolMatrix[n][m] = true;
 
                            QColor originalColor;
 
                            dstAccessor->moveTo(srcTopLeft.x() + l, srcTopLeft.y() + k);
                            cs->toQColor(dstAccessor->oldRawData(), &originalColor);
 
                            int newRed = CLAMP(originalColor.red() + Bright, 0, quint8_MAX);
                            int newGreen = CLAMP(originalColor.green() + Bright, 0, quint8_MAX);
                            int newBlue = CLAMP(originalColor.blue() + Bright, 0, quint8_MAX);
 
                            QColor newColor;
                            newColor.setRgb(newRed, newGreen, newBlue);
 
                            dstAccessor->moveTo(srcTopLeft.x() + n, srcTopLeft.y() + m);
                            cs->fromQColor(newColor, dstAccessor->rawData());
                        }
                    }
                }
            }
        }
 
        BlurRadius = NewSize / 25 + 1;
 
        for (i = -1 * halfSize - BlurRadius ; i < NewSize - halfSize + BlurRadius; i++) {
            for (j = -1 * halfSize - BlurRadius; j < NewSize - halfSize + BlurRadius; ++j) {
                r = sqrt((double)i * i + j * j);
 
                if (r <= Radius * 1.1) {
                    R = G = B = 0;
                    BlurPixels = 0;
 
                    for (k = -1 * BlurRadius; k < BlurRadius + 1; k++)
                        for (l = -1 * BlurRadius; l < BlurRadius + 1; l++) {
                            m = x + i + k;
                            n = y + j + l;
 
                            if ((m >= 0) && (m < Height) && (n >= 0) && (n < Width)) {
                                QColor color;
                                dstAccessor->moveTo(srcTopLeft.x() + n, srcTopLeft.y() + m);
                                cs->toQColor(dstAccessor->rawData(), &color);
 
                                R += color.red();
                                G += color.green();
                                B += color.blue();
                                BlurPixels++;
                            }
                        }
 
                    m = x + i;
                    n = y + j;
 
                    if ((m >= 0) && (m < Height) && (n >= 0) && (n < Width)) {
                        QColor color;
 
                        if (BlurPixels == 0) {
                            // Coverity complains that it *is* possible
                            // for BlurPixels to be 0, so let's make sure
                            // Krita doesn't crash here
                            BlurPixels = 1;
                        }
 
                        color.setRgb((int)(R / BlurPixels), (int)(G / BlurPixels), (int)(B / BlurPixels));
                        dstAccessor->moveTo(srcTopLeft.x() + n, srcTopLeft.y() + m);
                        cs->fromQColor(color, dstAccessor->rawData());
                    }
                }
            }
        }
 
        progressUpdater->setValue(NumBlurs);
    }
 
    FreeBoolArray(BoolMatrix, Width);
}

References B, CLAMP, KisPaintDevice::colorSpace(), CreateBoolArray(), KisPaintDevice::createRandomAccessorNG(), FreeBoolArray(), KoColorSpace::fromQColor(), G, KIS_SAFE_ASSERT_RECOVER_RETURN, KisRandomConstAccessorNG::moveTo(), KisBaseConstAccessor::oldRawData(), quint8_MAX, R, KisBaseAccessor::rawData(), KoUpdater::setRange(), KoUpdater::setValue(), and KoColorSpace::toQColor().

---

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

• plugins/filters/raindropsfilter/kis_raindrops_filter.h
• plugins/filters/raindropsfilter/kis_raindrops_filter.cpp