#include <KisSprayOpOptionData.h>

Inheritance diagram for KisSprayOpOptionData:

Public Types
enum	ParticleDistribution { ParticleDistribution_Uniform , ParticleDistribution_Gaussian , ParticleDistribution_ClusterBased , ParticleDistribution_CurveBased }

Public Member Functions
bool	read (const KisPropertiesConfiguration *setting)

void	write (KisPropertiesConfiguration *setting) const

Public Attributes
QString	angularDistributionCurve {DEFAULT_CURVE_STRING}

int	angularDistributionCurveRepeat {1}

ParticleDistribution	angularDistributionType {ParticleDistribution_Uniform}

qreal	aspect {1.0}

qreal	brushRotation {0.0}

qreal	coverage {0.003}

quint16	diameter {100}

qreal	jitterAmount {1.0}

bool	jitterMovement {false}

quint16	particleCount {12}

bool	radialDistributionCenterBiased {false}

qreal	radialDistributionClusteringAmount {0.0}

QString	radialDistributionCurve {DEFAULT_CURVE_STRING}

int	radialDistributionCurveRepeat {1}

qreal	radialDistributionStdDeviation {0.5}

ParticleDistribution	radialDistributionType {ParticleDistribution_Uniform}

qreal	scale {1.0}

qreal	spacing {0.5}

bool	useDensity {false}

Friends
bool	operator== (const KisSprayOpOptionData &lhs, const KisSprayOpOptionData &rhs)

Detailed Description

Definition at line 44 of file KisSprayOpOptionData.h.

Member Enumeration Documentation

◆ ParticleDistribution

enum KisSprayOpOptionData::ParticleDistribution

Enumerator
ParticleDistribution_Uniform
ParticleDistribution_Gaussian
ParticleDistribution_ClusterBased
ParticleDistribution_CurveBased

Definition at line 46 of file KisSprayOpOptionData.h.

    {
        ParticleDistribution_Uniform,
        ParticleDistribution_Gaussian,
        ParticleDistribution_ClusterBased,
        ParticleDistribution_CurveBased
    };

Member Function Documentation

◆ read()

bool KisSprayOpOptionData::read ( const KisPropertiesConfiguration * setting )

Definition at line 11 of file KisSprayOpOptionData.cpp.

{
    QVariant v;
    diameter = settings->getInt(SPRAY_DIAMETER);
    aspect = settings->getDouble(SPRAY_ASPECT);
    brushRotation = settings->getDouble(SPRAY_ROTATION);
    scale = settings->getDouble(SPRAY_SCALE);
    spacing = settings->getDouble(SPRAY_SPACING);
    jitterMovement = settings->getBool(SPRAY_JITTER_MOVEMENT);
    jitterAmount = settings->getDouble(SPRAY_JITTER_MOVE_AMOUNT);
    particleCount = settings->getDouble(SPRAY_PARTICLE_COUNT);
    coverage = settings->getDouble(SPRAY_COVERAGE) / 100.0;
    useDensity = settings->getBool(SPRAY_USE_DENSITY);
    {
        const QString angularDistributionTypeStr = settings->getString(SPRAY_ANGULAR_DISTRIBUTION_TYPE, "uniform");
        if (angularDistributionTypeStr == "curveBased") {
            angularDistributionType = ParticleDistribution_CurveBased;
        } else {
            angularDistributionType = ParticleDistribution_Uniform;
        }
        angularDistributionCurve = settings->getString(SPRAY_ANGULAR_DISTRIBUTION_CURVE, DEFAULT_CURVE_STRING);
        angularDistributionCurveRepeat = settings->getInt(SPRAY_ANGULAR_DISTRIBUTION_CURVE_REPEAT, 1);
    }
    {
        const QString radialDistributionTypeStr = settings->getString(SPRAY_RADIAL_DISTRIBUTION_TYPE, "");
        if (radialDistributionTypeStr == "uniform") {
            radialDistributionType = ParticleDistribution_Uniform;
        } else if (radialDistributionTypeStr == "gaussian") {
            radialDistributionType = ParticleDistribution_Gaussian;
        } else if (radialDistributionTypeStr == "clusterBased") {
            radialDistributionType = ParticleDistribution_ClusterBased;
        } else if (radialDistributionTypeStr == "curveBased") {
            radialDistributionType = ParticleDistribution_CurveBased;
        } else {
            // Old brush
            if (settings->getBool(SPRAY_GAUSS_DISTRIBUTION, false)) {
                radialDistributionType = ParticleDistribution_Gaussian;
            } else {
                radialDistributionType = ParticleDistribution_Uniform;
            }
        }
        radialDistributionStdDeviation = settings->getDouble(SPRAY_RADIAL_DISTRIBUTION_STD_DEVIATION, 0.5);
        radialDistributionClusteringAmount = settings->getDouble(SPRAY_RADIAL_DISTRIBUTION_CLUSTERING_AMOUNT, 0.0);
        radialDistributionCurve = settings->getString(SPRAY_RADIAL_DISTRIBUTION_CURVE, DEFAULT_CURVE_STRING);
        radialDistributionCurveRepeat = settings->getInt(SPRAY_RADIAL_DISTRIBUTION_CURVE_REPEAT, 1);
        radialDistributionCenterBiased = settings->getBool(SPRAY_RADIAL_DISTRIBUTION_CENTER_BIASED, true);
    }
    return true;
}

References angularDistributionCurve, angularDistributionCurveRepeat, angularDistributionType, aspect, brushRotation, coverage, DEFAULT_CURVE_STRING, diameter, KisPropertiesConfiguration::getBool(), KisPropertiesConfiguration::getDouble(), KisPropertiesConfiguration::getInt(), KisPropertiesConfiguration::getString(), jitterAmount, jitterMovement, particleCount, ParticleDistribution_ClusterBased, ParticleDistribution_CurveBased, ParticleDistribution_Gaussian, ParticleDistribution_Uniform, radialDistributionCenterBiased, radialDistributionClusteringAmount, radialDistributionCurve, radialDistributionCurveRepeat, radialDistributionStdDeviation, radialDistributionType, scale, spacing, SPRAY_ANGULAR_DISTRIBUTION_CURVE, SPRAY_ANGULAR_DISTRIBUTION_CURVE_REPEAT, SPRAY_ANGULAR_DISTRIBUTION_TYPE, SPRAY_ASPECT, SPRAY_COVERAGE, SPRAY_DIAMETER, SPRAY_GAUSS_DISTRIBUTION, SPRAY_JITTER_MOVE_AMOUNT, SPRAY_JITTER_MOVEMENT, SPRAY_PARTICLE_COUNT, SPRAY_RADIAL_DISTRIBUTION_CENTER_BIASED, SPRAY_RADIAL_DISTRIBUTION_CLUSTERING_AMOUNT, SPRAY_RADIAL_DISTRIBUTION_CURVE, SPRAY_RADIAL_DISTRIBUTION_CURVE_REPEAT, SPRAY_RADIAL_DISTRIBUTION_STD_DEVIATION, SPRAY_RADIAL_DISTRIBUTION_TYPE, SPRAY_ROTATION, SPRAY_SCALE, SPRAY_SPACING, SPRAY_USE_DENSITY, useDensity, and v.

◆ write()

void KisSprayOpOptionData::write ( KisPropertiesConfiguration * setting ) const

Definition at line 61 of file KisSprayOpOptionData.cpp.

{
    setting->setProperty(SPRAY_DIAMETER, diameter);
    setting->setProperty(SPRAY_ASPECT, aspect);
    setting->setProperty(SPRAY_ROTATION, brushRotation);
    setting->setProperty(SPRAY_SCALE, scale);
    setting->setProperty(SPRAY_SPACING, spacing);
    setting->setProperty(SPRAY_JITTER_MOVEMENT, jitterMovement);
    setting->setProperty(SPRAY_JITTER_MOVE_AMOUNT, jitterAmount);
    setting->setProperty(SPRAY_PARTICLE_COUNT, particleCount);
    setting->setProperty(SPRAY_COVERAGE, coverage * 100.0);
    setting->setProperty(SPRAY_USE_DENSITY, useDensity);
    if (angularDistributionType == ParticleDistribution_CurveBased) {
        setting->setProperty(SPRAY_ANGULAR_DISTRIBUTION_TYPE, "curveBased");
    } else {
        setting->setProperty(SPRAY_ANGULAR_DISTRIBUTION_TYPE, "uniform");
    }
    if (radialDistributionType == ParticleDistribution_Gaussian) {
        setting->setProperty(SPRAY_GAUSS_DISTRIBUTION, true);
        setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_TYPE, "gaussian");
    } else if (radialDistributionType == ParticleDistribution_ClusterBased) {
        setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_TYPE, "clusterBased");
    } else if (radialDistributionType == ParticleDistribution_CurveBased) {
        setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_TYPE, "curveBased");
    } else {
        setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_TYPE, "uniform");
    }
    QVariant c;
    c.setValue(angularDistributionCurve);
    setting->setProperty(SPRAY_ANGULAR_DISTRIBUTION_CURVE, c);
    setting->setProperty(SPRAY_ANGULAR_DISTRIBUTION_CURVE_REPEAT, angularDistributionCurveRepeat);
    setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_STD_DEVIATION, radialDistributionStdDeviation);
    setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_CLUSTERING_AMOUNT, radialDistributionClusteringAmount);
    c.setValue(radialDistributionCurve);
    setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_CURVE, c);
    setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_CURVE_REPEAT, radialDistributionCurveRepeat);
    setting->setProperty(SPRAY_GAUSS_DISTRIBUTION, radialDistributionType == ParticleDistribution_Gaussian);
    setting->setProperty(SPRAY_RADIAL_DISTRIBUTION_CENTER_BIASED, radialDistributionCenterBiased);
}

References angularDistributionCurve, angularDistributionCurveRepeat, angularDistributionType, aspect, brushRotation, coverage, diameter, jitterAmount, jitterMovement, particleCount, ParticleDistribution_ClusterBased, ParticleDistribution_CurveBased, ParticleDistribution_Gaussian, radialDistributionCenterBiased, radialDistributionClusteringAmount, radialDistributionCurve, radialDistributionCurveRepeat, radialDistributionStdDeviation, radialDistributionType, scale, KisPropertiesConfiguration::setProperty(), spacing, SPRAY_ANGULAR_DISTRIBUTION_CURVE, SPRAY_ANGULAR_DISTRIBUTION_CURVE_REPEAT, SPRAY_ANGULAR_DISTRIBUTION_TYPE, SPRAY_ASPECT, SPRAY_COVERAGE, SPRAY_DIAMETER, SPRAY_GAUSS_DISTRIBUTION, SPRAY_JITTER_MOVE_AMOUNT, SPRAY_JITTER_MOVEMENT, SPRAY_PARTICLE_COUNT, SPRAY_RADIAL_DISTRIBUTION_CENTER_BIASED, SPRAY_RADIAL_DISTRIBUTION_CLUSTERING_AMOUNT, SPRAY_RADIAL_DISTRIBUTION_CURVE, SPRAY_RADIAL_DISTRIBUTION_CURVE_REPEAT, SPRAY_RADIAL_DISTRIBUTION_STD_DEVIATION, SPRAY_RADIAL_DISTRIBUTION_TYPE, SPRAY_ROTATION, SPRAY_SCALE, SPRAY_SPACING, SPRAY_USE_DENSITY, and useDensity.

Friends And Related Symbol Documentation

◆ operator==

bool operator==	(	const KisSprayOpOptionData &	lhs,
		const KisSprayOpOptionData &	rhs )

friend

Definition at line 54 of file KisSprayOpOptionData.h.

                                                                                                    {
        return lhs.diameter == rhs.diameter // 10 entries
            && lhs.aspect == rhs.aspect
            && lhs.brushRotation == rhs.brushRotation
            && lhs.scale == rhs.scale
            && lhs.spacing == rhs.spacing
            && lhs.jitterMovement == rhs.jitterMovement
            && lhs.jitterAmount == rhs.jitterAmount
            && lhs.useDensity == rhs.useDensity
            && lhs.particleCount == rhs.particleCount
            && lhs.coverage == rhs.coverage
            // 9 entries
            && lhs.angularDistributionType == rhs.angularDistributionType
            && lhs.angularDistributionCurve == rhs.angularDistributionCurve
            && lhs.angularDistributionCurveRepeat == rhs.angularDistributionCurveRepeat
            && lhs.radialDistributionType == rhs.radialDistributionType
            && lhs.radialDistributionStdDeviation == rhs.radialDistributionStdDeviation
            && lhs.radialDistributionClusteringAmount == rhs.radialDistributionClusteringAmount
            && lhs.radialDistributionCurve == rhs.radialDistributionCurve
            && lhs.radialDistributionCurveRepeat == rhs.radialDistributionCurveRepeat
            && lhs.radialDistributionCenterBiased == rhs.radialDistributionCenterBiased;
            // 7 entries - but there is no need to compare functors
            
    }

Member Data Documentation

◆ angularDistributionCurve

QString KisSprayOpOptionData::angularDistributionCurve {DEFAULT_CURVE_STRING}

Definition at line 95 of file KisSprayOpOptionData.h.

95{DEFAULT_CURVE_STRING};

◆ angularDistributionCurveRepeat

int KisSprayOpOptionData::angularDistributionCurveRepeat {1}

Definition at line 96 of file KisSprayOpOptionData.h.

96{1};

◆ angularDistributionType

ParticleDistribution KisSprayOpOptionData::angularDistributionType {ParticleDistribution_Uniform}

Definition at line 94 of file KisSprayOpOptionData.h.

94{ParticleDistribution_Uniform};

◆ aspect

qreal KisSprayOpOptionData::aspect {1.0}

Definition at line 83 of file KisSprayOpOptionData.h.

83{1.0};

◆ brushRotation

qreal KisSprayOpOptionData::brushRotation {0.0}

Definition at line 84 of file KisSprayOpOptionData.h.

84{0.0};

◆ coverage

qreal KisSprayOpOptionData::coverage {0.003}

Definition at line 91 of file KisSprayOpOptionData.h.

91{0.003};

◆ diameter

quint16 KisSprayOpOptionData::diameter {100}

Definition at line 82 of file KisSprayOpOptionData.h.

82{100};

◆ jitterAmount

qreal KisSprayOpOptionData::jitterAmount {1.0}

Definition at line 88 of file KisSprayOpOptionData.h.

88{1.0};

◆ jitterMovement

bool KisSprayOpOptionData::jitterMovement {false}

Definition at line 87 of file KisSprayOpOptionData.h.

87{false};

◆ particleCount

quint16 KisSprayOpOptionData::particleCount {12}

Definition at line 90 of file KisSprayOpOptionData.h.

90{12};

◆ radialDistributionCenterBiased

bool KisSprayOpOptionData::radialDistributionCenterBiased {false}

Definition at line 102 of file KisSprayOpOptionData.h.

102{false};

◆ radialDistributionClusteringAmount

qreal KisSprayOpOptionData::radialDistributionClusteringAmount {0.0}

Definition at line 99 of file KisSprayOpOptionData.h.

99{0.0};

◆ radialDistributionCurve

QString KisSprayOpOptionData::radialDistributionCurve {DEFAULT_CURVE_STRING}

Definition at line 100 of file KisSprayOpOptionData.h.

100{DEFAULT_CURVE_STRING};

◆ radialDistributionCurveRepeat

int KisSprayOpOptionData::radialDistributionCurveRepeat {1}

Definition at line 101 of file KisSprayOpOptionData.h.

101{1};

◆ radialDistributionStdDeviation

qreal KisSprayOpOptionData::radialDistributionStdDeviation {0.5}

Definition at line 98 of file KisSprayOpOptionData.h.

98{0.5};

◆ radialDistributionType

ParticleDistribution KisSprayOpOptionData::radialDistributionType {ParticleDistribution_Uniform}

Definition at line 97 of file KisSprayOpOptionData.h.

97{ParticleDistribution_Uniform};

◆ scale

qreal KisSprayOpOptionData::scale {1.0}

Definition at line 85 of file KisSprayOpOptionData.h.

85{1.0};

◆ spacing

qreal KisSprayOpOptionData::spacing {0.5}

Definition at line 86 of file KisSprayOpOptionData.h.

86{0.5};

◆ useDensity

bool KisSprayOpOptionData::useDensity {false}

Definition at line 89 of file KisSprayOpOptionData.h.

89{false};

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

plugins/paintops/spray/KisSprayOpOptionData.h
plugins/paintops/spray/KisSprayOpOptionData.cpp

Public Types

Public Member Functions

Public Attributes

Friends