Calcular pontos aleatórios (pixel) dentro de um círculo (imagem)

Eu tenho uma imagem que contém círculos em um local específico e com um diâmetro específico. O que preciso fazer é ser capaz de calcular pontos aleatórios dentro do círculo e manipular os pixels aos quais os pontos se correlacionam. Eu já tenho o seguinte código:

private Point CalculatePoint()
{
    var angle = _random.NextDouble() * ( Math.PI * 2 );
    var x = _originX + ( _radius * Math.Cos( angle ) );
    var y = _originY + ( _radius * Math.Sin( angle ) );
    return new Point( ( int )x, ( int )y );
}

E isso funciona bem para encontrar todos os pontos na circunferência do círculo, mas eu preciso de todos os pontos de qualquer lugar do círculo. Se isso não fizer sentido, avise-me e farei o possível para esclarecer.

Se você deseja uma solução simples, apenas randomize o raio também:

private Point CalculatePoint()
{
    var angle = _random.NextDouble() * Math.PI * 2;
    var radius = _random.NextDouble() * _radius;
    var x = _originX + radius * Math.Cos(angle);
    var y = _originY + radius * Math.Sin(angle);
    return new Point((int)x,(int)y);
}

No entanto, isso resulta em seus pontos mais concentrados em direção ao centro do círculo:

Para obter uma distribuição uniforme, faça a seguinte alteração no algoritmo:

var radius = Math.Sqrt(_random.NextDouble()) * _radius;

O que dará o seguinte resultado:

Para mais informações, consulte o seguinte link: MathWorld - Seleção de ponto de disco .

E finalmente, aqui está uma demonstração simples do JsFiddle comparando as duas versões do algoritmo.

NÃO use apenas r aleatório e teta! Isso cria uma distribuição ponderada com mais pontos no centro. Esta página ilustra bem ...

http://mathworld.wolfram.com/DiskPointPicking.html

Aqui está o método que cria uma distribuição não ponderada ...

var r = rand(0,1)
var theta = rand(0,360)

var x = sqrt(r) * cos(theta)
var y = sqrt(r) * sin(theta)

Você está no meio do caminho. Além de gerar um ângulo aleatório, apenas gere uma distância aleatória, menor ou igual ao raio, ponderada para obter uma distribuição uniforme:

private Point CalculatePoint()
{
    var angle = _random.NextDouble() * Math.PI * 2;
    var distance = Math.Sqrt(_random.NextDouble()) * _radius;
    var x = _originX + (distance * Math.Cos(angle));
    var y = _originY + (distance * Math.Sin(angle));
    return new Point((int)x, (int)y);
}

Agora você está pensando com polar .

Você também pode ponderar a distância dessa maneira para evitar uma raiz quadrada:

var distance = _random.NextDouble() + _random.NextDouble();
distance = (distance <= 1 ? distance : 2 - distance) * _radius;

Se o desempenho é um problema, uma solução alternativa é gerar uma posição aleatória em uma caixa com a largura / altura do seu círculo e jogar fora quaisquer pontos que não estejam na área do círculo.

A vantagem desse método é que você não está executando funções cos / sin / sqrt, o que, dependendo da sua plataforma, pode ser uma grande economia de velocidade.

var x = _random.NextDouble();
var y = _random.NextDouble();
if (x*x + y*y < 1.0f)
{
    // we have a usable point inside a circle
    x = x * diameter - _radius + _OriginX;
    y = y * diameter - _radius + _OriginY;
    // use the point(x,y)
}

Adotei a abordagem de um dos comentários listados e estendi a funcionalidade para criar um sistema de geração de pontos em forma de anel.

            private Vector2 CalculatePosition()
            {
                double angle = _rnd.NextDouble() * Math.PI * 2;
                double radius = InnerCircleRadius + (Math.Sqrt(_rnd.NextDouble()) * (OuterCircleRadius - InnerCircleRadius));
                double x = (_context.ScreenLayout.Width * 0.5f) + (radius * Math.Cos(angle));
                double y = (_context.ScreenLayout.Height * 0.5f) + (radius * Math.Sin(angle));
                return new Vector2((int)x, (int)y);
            }

É uma abordagem semelhante à mencionada anteriormente, mas forneceu resultados diferentes. A parte interna do círculo será deixada em branco sem pontos.