KisSprayFunctionBasedDistribution::Private Class Reference

Classes
struct	SampleInfo

Public Member Functions
double	generate (double randomValue) const
template<typename Function >
void	initialize (size_t numberOfSamples, double a, double b, Function f)

Public Attributes
std::vector< SampleInfo >	samples

Detailed Description

Definition at line 14 of file KisSprayRandomDistributions.cpp.

Member Function Documentation

generate()

double KisSprayFunctionBasedDistribution::Private::generate ( double randomValue ) const

inline

Definition at line 151 of file KisSprayRandomDistributions.cpp.

    {
        // Find the first sample that has cdf greater than the passed value
        auto sampleIterator =
            std::upper_bound(samples.begin(), samples.end(), SampleInfo{0.0, randomValue, 0.0},
                             kismpl::mem_less(&SampleInfo::cdfAtX));
        const double t = (randomValue - (sampleIterator - 1)->cdfAtX) * sampleIterator->oneOverCdfDy;
        return (sampleIterator - 1)->x + t * (sampleIterator->x - (sampleIterator - 1)->x);
    }

References KisSprayFunctionBasedDistribution::Private::SampleInfo::cdfAtX, kismpl::mem_less(), and samples.

initialize()

template<typename Function >

void KisSprayFunctionBasedDistribution::Private::initialize ( size_t numberOfSamples, double a, double b, Function f )

inline

Definition at line 27 of file KisSprayRandomDistributions.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN(numberOfSamples > 0);
        KIS_SAFE_ASSERT_RECOVER_RETURN(b > a);
 
        samples.clear();
 
        if (numberOfSamples < 3) {
            samples.push_back({a, 0.0, 0.0});
            samples.push_back({b, 1.0, 1.0});
            return;
        }
 
        // Create the CDF
        const double domainSize = b - a;
        const double intervalSize = domainSize / static_cast<double>(numberOfSamples - 1);
        double sum = 0.0;
        double lastX, lastY, lastSum;
        size_t effectiveNumberOfSamples = numberOfSamples;
 
        // Adjust the limits of the pdf if it has a 0 probability segment at
        // the start or at the end
        {
            for (size_t i = 0; i < numberOfSamples; ++i) {
                const double x = a + intervalSize * static_cast<double>(i);
                const double y = f(x);
                if (y > 0.0) {
                    if (i > 0) {
                        a += intervalSize * static_cast<double>(i - 1);
                        effectiveNumberOfSamples -= i - 1;
                    }
                    break;
                }
                if (i == numberOfSamples - 1) {
                    // The whole pdf must have 0 probability
                    return;
                }
            }
 
            for (size_t i = 0; i < numberOfSamples; ++i) {
                const double x = b - intervalSize * static_cast<double>(i);
                const double y = f(x);
                if (y > 0.0) {
                    if (i > 0) {
                        b -= intervalSize * static_cast<double>(i - 1);
                        effectiveNumberOfSamples -= i - 1;
                    }
                    break;
                }
            }
        }
        // Insert first point
        {
            samples.push_back({a, 0.0, 0.0});
            lastX = a;
            lastY = f(a);
            lastSum = 0.0;
        }
        // Insert the rest of the points
        {
            // This angle serves as a reference to see if the cdf curve is
            // roughly straight, and remove some points
            constexpr double maximumAngleDeviationToSkip{M_PI / 1000.0};
            double referenceAngle = 0.0;
            bool mustCheckAngle = false;
            int skippedPoints = 0;
 
            for (size_t i = 1; i < effectiveNumberOfSamples; ++i) {
                const double x = a + intervalSize * static_cast<double>(i);
                const double y = f(x);
                // Accumulate the area under the curve between the two points
                sum += (x - lastX) * (y + lastY) / 2.0;
                //
                if (y == 0.0) {
                    if (lastY == 0.0) {
                        lastX = x;
                        lastY = y;
                        lastSum = sum;
                        ++skippedPoints;
                        continue;
                    } else {
                        mustCheckAngle = false;
                    }
                } else {
                    if (lastY == 0.0) {
                        if (skippedPoints > 0) {
                            samples.push_back({lastX, lastSum, 0.0});
                        }
                        mustCheckAngle = false;
                    }
                }
 
                // Compute if the current point is nearly colinear to the last two points
                if (i > 1 && mustCheckAngle) {
                    const int nPoints = samples.size();
                    const double angle = std::atan2(sum - samples[nPoints - 2].cdfAtX, x - samples[nPoints - 2].x);
                    if (std::abs(angle - referenceAngle) <= maximumAngleDeviationToSkip) {
                        samples.back().x = x;
                        samples.back().cdfAtX = sum;
                        continue;
                    }
                }
 
                samples.push_back({x, sum, 0.0});
                referenceAngle = std::atan2(sum - lastSum, x - lastX);
                mustCheckAngle = true;
                skippedPoints = 0;
 
                lastX = x;
                lastY = y;
                lastSum = sum;
            }
        }
        // Scale the cdf to the [0..1] range and compute deltas
        {
            for (size_t i = 1; i < samples.size() - 1; ++i) {
                samples[i].cdfAtX /= sum;
                samples[i].oneOverCdfDy = 1.0 / (samples[i].cdfAtX - samples[i - 1].cdfAtX);
            }
            samples.back().cdfAtX = 1.0;
            samples.back().oneOverCdfDy = 1.0 / (1.0 - samples[samples.size() - 2].cdfAtX);
        }
    }

References KIS_SAFE_ASSERT_RECOVER_RETURN, M_PI, and samples.

Member Data Documentation

samples

std::vector<SampleInfo> KisSprayFunctionBasedDistribution::Private::samples

Definition at line 24 of file KisSprayRandomDistributions.cpp.

---

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

• plugins/paintops/spray/KisSprayRandomDistributions.cpp