Calcular puntos aleatorios (píxeles) dentro de un círculo (imagen)

Tengo una imagen que contiene círculos en una ubicación específica y de un diámetro específico. Lo que tengo que hacer es poder calcular puntos aleatorios dentro del círculo y luego manipular los píxeles con los que se correlacionan dichos puntos. Ya tengo el siguiente 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 );
}

Y eso funciona bien para encontrar todos los puntos en la circunferencia del círculo, pero necesito todos los puntos de cualquier parte del círculo. Si esto no tiene sentido, hágamelo saber y haré todo lo posible para aclararlo.

Si desea una solución simple, simplemente aleatorice el radio también:

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);
}

Sin embargo, eso hace que tus puntos se concentren más hacia el centro del círculo:

Para obtener una distribución uniforme, realice el siguiente cambio en el algoritmo:

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

Lo que dará el siguiente resultado:

Para obtener más información, consulte el siguiente enlace: MathWorld - Selección de punto de disco .

Y finalmente, aquí hay una demostración simple de JsFiddle que compara ambas versiones del algoritmo.

¡NO use simplemente r y theta al azar! Esto crea una distribución ponderada con más puntos en el centro. Esta página lo ilustra bien ...

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

Aquí está el método que crea una distribución no ponderada ...

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

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

Estás a medio camino. Además de generar un ángulo aleatorio, solo genera una distancia aleatoria, menor o igual que el radio, ponderada para obtener una distribución 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);
}

Ahora estás pensando con polar .

También puede pesar la distancia de esta manera para evitar una raíz cuadrada:

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

Si el rendimiento es un problema, entonces una solución alternativa es generar una posición aleatoria en un cuadro con el ancho / alto de su círculo y luego tirar cualquier punto que no esté en el área del círculo.

La ventaja de este método es que no está haciendo funciones cos / sin / sqrt, lo que dependiendo de su plataforma puede ser un gran ahorro de velocidad.

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

Tomé el enfoque de uno de los comentarios enumerados y amplié la funcionalidad para crear un sistema de generación de puntos en forma de rosquilla.

            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);
            }

Es un enfoque similar al mencionado anteriormente, pero proporcionó resultados diferentes. La parte interna del círculo se dejará en blanco sin puntos.