#include <simplexnoisegenerator.h>

Inheritance diagram for KisSimplexNoiseGenerator:

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

KisFilterConfigurationSP	defaultConfiguration (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

	KisSimplexNoiseGenerator ()

quint64	rotateLeft (const quint64 input, uint d) const

uint	seedFromString (const QString &string) const

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

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

static double	map_range (double value, double curr_min, double curr_max, double new_min, double new_max)

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 26 of file simplexnoisegenerator.h.

Constructor & Destructor Documentation

◆ KisSimplexNoiseGenerator()

KisSimplexNoiseGenerator::KisSimplexNoiseGenerator ( )

Definition at line 38 of file simplexnoisegenerator.cpp.

                                                   : KisGenerator(id(), KoID("basic"), i18n("&Simplex Noise..."))
{
    setColorSpaceIndependence(FULLY_INDEPENDENT);
    setSupportsPainting(true);
}

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

Member Function Documentation

◆ createConfigurationWidget()

KisConfigWidget * KisSimplexNoiseGenerator::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 125 of file simplexnoisegenerator.cpp.

{
    Q_UNUSED(dev);
    return new KisWdgSimplexNoise((KisFilter*)this, (QWidget*)parent);
}

◆ defaultConfiguration()

KisFilterConfigurationSP KisSimplexNoiseGenerator::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 112 of file simplexnoisegenerator.cpp.

{
    KisFilterConfigurationSP config = factoryConfiguration(resourcesInterface);
    config->setProperty("looping", false);
    config->setProperty("frequency", 25.0);
    uint seed = static_cast<uint>(rand());
    config->setProperty("seed", seed);
    config->setProperty("custom_seed_string", "");
    config->setProperty("ratio_x", 1.0f);
    config->setProperty("ratio_y", 1.0f);
    return config;
}

References KisBaseProcessor::factoryConfiguration().

◆ generate() [1/3]

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/3]

void KisSimplexNoiseGenerator::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 44 of file simplexnoisegenerator.cpp.

{
    KisPaintDeviceSP device = dst.paintDevice();
    Q_ASSERT(!device.isNull());
 
    osn_context *noise_context;
 
    QRect bounds = QRect(dst.topLeft(), size);
    QRect whole_image_bounds = device->defaultBounds()->bounds();
 
    const KoColorSpace *cs = device->colorSpace();
    const KoColorSpace *src = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Float32BitsColorDepthID.id(), "Gray-D50-elle-V2-srgbtrc.icc");
    KoColorConversionTransformation *conv = KoColorSpaceRegistry::instance()->createColorConverter(src, cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
    KisSequentialIteratorProgress it(device, bounds, progressUpdater);
 
    QVariant property;
 
    const uint default_seed = (config->getProperty("seed", property)) ? property.toUInt() : 0;
    const QString custom_seed_string = (config->getProperty("custom_seed_string", property)) ? property.toString() : "";
    const bool use_custom_seed = !custom_seed_string.trimmed().isEmpty();
 
    const uint seed = use_custom_seed ? seedFromString(custom_seed_string) : default_seed;
    open_simplex_noise(seed, &noise_context);
 
    double frequency = (config && config->getProperty("frequency", property)) ? property.toDouble() : 25.0;
    double ratio_x = (config && config->getProperty("ratio_x", property)) ? property.toDouble() : 1.0;
    double ratio_y = (config && config->getProperty("ratio_y", property)) ? property.toDouble() : 1.0;
 
    bool looping = (config && config->getProperty("looping", property)) ? property.toBool() : false;
 
    if( looping ){
        float major_radius = 0.5f * frequency * ratio_x;
        float minor_radius = 0.5f * frequency * ratio_y;
        while(it.nextPixel()){
            double x_phase = (double)it.x() / (double)whole_image_bounds.width() * M_PI * 2;
            double y_phase = (double)it.y() / (double)(whole_image_bounds.height()) * M_PI * 2;
            double x_coordinate = major_radius * map_range(cos(x_phase), -1.0, 1.0, 0.0, 1.0);
            double y_coordinate = major_radius * map_range(sin(x_phase), -1.0, 1.0, 0.0, 1.0);
            double z_coordinate = minor_radius * map_range(cos(y_phase), -1.0, 1.0, 0.0, 1.0);
            double w_coordinate = minor_radius * map_range(sin(y_phase), -1.0, 1.0, 0.0, 1.0);
            double value = open_simplex_noise4(noise_context, x_coordinate, y_coordinate, z_coordinate, w_coordinate);
            value = map_range(value, -1.0, 1.0, 0.0, 1.0);
 
            KoColor c(src);
            reinterpret_cast<float *>(c.data())[0] = value;
            c.setOpacity(OPACITY_OPAQUE_F);
 
            conv->transform(c.data(), it.rawData(), 1);
        }
    } else {
        while(it.nextPixel()){
            double x_phase = (double)it.x() / (double)(whole_image_bounds.width()) * ratio_x;
            double y_phase = (double)it.y() / (double)(whole_image_bounds.height()) * ratio_y;
            double value = open_simplex_noise4(noise_context, x_phase * frequency, y_phase * frequency, x_phase * frequency, y_phase * frequency);
            value = map_range(value, -1.0, 1.0, 0.0, 1.0);
 
            KoColor c(src);
            reinterpret_cast<float *>(c.data())[0] = value;
            c.setOpacity(OPACITY_OPAQUE_F);
 
            conv->transform(c.data(), it.rawData(), 1);
        }
    }
    delete conv;
    open_simplex_noise_free(noise_context);
}

References KisDefaultBoundsBase::bounds(), bounds, KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpaceRegistry::createColorConverter(), KoColor::data(), KisPaintDevice::defaultBounds(), Float32BitsColorDepthID, GrayAColorModelID, KoID::id(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisSharedPtr< T >::isNull(), M_PI, map_range(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), OPACITY_OPAQUE_F, open_simplex_noise(), open_simplex_noise4(), open_simplex_noise_free(), KisProcessingInformation::paintDevice(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), seedFromString(), KoColor::setOpacity(), KisConstProcessingInformation::topLeft, KoColorConversionTransformation::transform(), value(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

◆ generate() [3/3]

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.

◆ id()

static KoID KisSimplexNoiseGenerator::id ( )

inlinestatic

Definition at line 39 of file simplexnoisegenerator.h.

                            {
        return KoID("simplex_noise", i18n("Simplex Noise"));
    }

◆ map_range()

static double KisSimplexNoiseGenerator::map_range	(	double	value,
		double	curr_min,
		double	curr_max,
		double	new_min,
		double	new_max )

inlinestatic

Definition at line 49 of file simplexnoisegenerator.h.

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

References value().

◆ rotateLeft()

quint64 KisSimplexNoiseGenerator::rotateLeft	(	const quint64	input,
		uint	d ) const

Definition at line 142 of file simplexnoisegenerator.cpp.

{
    return (input << shift)|(input >> (64 - shift));
}

◆ seedFromString()

uint KisSimplexNoiseGenerator::seedFromString ( const QString & string ) const

Definition at line 132 of file simplexnoisegenerator.cpp.

{
    QByteArray bytes = QCryptographicHash::hash(string.toUtf8(),QCryptographicHash::Md5);
    uint hash = 0;
    for( int index = 0; index < bytes.length(); index++){
        hash += rotateLeft(bytes[index], index % 32);
    }
    return hash;
}

References rotateLeft().

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

plugins/generators/simplexnoise/simplexnoisegenerator.h
plugins/generators/simplexnoise/simplexnoisegenerator.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisSimplexNoiseGenerator()

Member Function Documentation

◆ createConfigurationWidget()

◆ defaultConfiguration()

◆ generate() [1/3]

◆ generate() [2/3]

◆ generate() [3/3]

◆ id()

◆ map_range()

◆ rotateLeft()

◆ seedFromString()