Fill a vector with a specific distribution of nonuniform screen points

Question

I am trying to fill a vector with a specific distribution of nonuniform screen points. These points represent some x and y position on the screen. At some point I am going to draw all of these points on the screen, which should be unevenly distributed at the center. Basically, the frequency of points should increase as you get closer to the center, where one side of the screen is a reflection of the other (can "Mirror over the center of the screen")

I was thinking about using some sort of formula (like y=cos(x) between -pi/2 and pi/2) where the resulting y would equal the frequency of the points in that area of the screen (where -pi/2 would be the leftmost side of the screen, vice versa), but I got stuck on how I would even be able to apply something like this when creating points to put onto the vector. Note: There is a specific number of points that must be generated

If the above hypothesis is not able to work, maybe a cheaty way of achieving this would be to constantly reduce some step size between each point, but I don't know how I would be able to ensure that the specific number of points reach the center.

Ex.

// this is a member function inside a class PointList
// where we fill a member variable list(vector) with nonuniform data
void PointList::FillListNonUniform(const int numPoints, const int numPerPoint)
{
    double step = 2;
    double decelerator = 0.01;

    // Do half the screen then duplicate and reverse the sign
    // so both sides of the screen mirror eachother
    for (int i = 0; i < numPoints / 2; i++)
    {
        Eigen::Vector2d newData(step, 0);
        for (int j = 0; j < numPerPoint; j++)
        {
            list.push_back(newData);
        }
        decelerator += 0.01f;
        step -= 0.05f + decelerator;
    }

    // Do whatever I need to, to mirror the points ...
}

Literally any help would be a appreciated. I have briefly looked into std::normal_distribution, but it appears to me that it relies on randomness, so I am unsure if this would be a good option for what I am trying to do.

For example, you could use polar coordinates and uniform distributions over `r` and `phi`. — Evg, Jul 31 '21 at 18:57

score 3 · Answer 1 · answered Jul 31 '21 at 19:16

You can use something called rejection sampling. The idea is that you have some function of some parameters (in your case 2 parameters x, y), which represents the probability density function. In your 2D case, you can then generate an x, y pair along with a variable representing the probability p. If the probability density function is larger at the coordinates (i.e. f(x, y) > p), the sample is added, otherwise a new pair is generated. You can implement this like:

#include <functional>
#include <vector>
#include <utility>
#include <random>

std::vector<std::pair<double,double>> getDist(int num){

    std::random_device rd{};
    std::mt19937 gen{rd()};

    auto pdf = [] (double x, double y) {
        return /* Some probability density function */;
    };

    std::vector<std::pair<double,double>> ret;
    
    double x,y,p;

    while(ret.size() <= num){
        x = (double)gen()/SOME_CONST_FOR_X;
        y = (double)gen()/SOME_CONST_FOR_Y;
        p = (double)gen()/SOME_CONST_FOR_P;

        if(pdf(x,y) > p) ret.push_back({x,y});
    }
    return ret;
}

This is a very crude draft but should give and idea as to how this might work.

An other option (if you want normal distribution), would be std::normal_distribution. The example from the reference page can be adapted so:

#include <random>
#include <vector>
#include <utility>

std::vector<std::pair<double,double>> getDist(int num){

    std::random_device rd{};
    std::mt19937 gen{rd()};

    std::normal_distribution<> d_x{x_center,x_std};
    std::normal_distribution<> d_y{y_center,y_std};
 
    while(ret.size() <= num){
        ret.push_back({d_x(gen),d_y(gen)});
    }

}

G. Sliepen · Answer 2 · 2021-07-31T23:46:19.127

There are various ways to approach this, depending on the exact distribution you want. Generally speaking, if you have a distribution function f(x) that gives you the probability of a point at a specific distance to the center, then you can integrate it to get the cumulative distribution function F(x). If the CDF can be inverted, you can use the inverse CDF to map a uniform random variable to distances from the center, such that you get the desired distribution. But not all functions are easily inverted.

Another option would be to fake it a little bit: for example, make a loop that goes from 0 to the maximum distance from the center, and then for each distance you use the probability function to get the expected number of points at that distance. Then just add exactly that many points at randomly chosen angles. This is quite fast and the result might just be good enough.

Rejection sampling as mentioned by Lala5th is another option, giving you the desired distribution, but potentially taking a long time if large areas of the screen have a very low probability. A way to ensure it finishes in bounded time is to not loop until you have num points added, but to loop over every pixel, and add the coordinates of that pixel if pdf(x,y) > p. The drawback of that is that you won't get exactly num points.

Fill a vector with a specific distribution of nonuniform screen points

2 Answers2