Calculer des points aléatoires (pixel) dans un cercle (image)

J'ai une image qui contient des cercles à un endroit spécifique et d'un diamètre spécifique. Ce que je dois faire, c'est être capable de calculer des points aléatoires dans le cercle, puis de manipuler les pixels auxquels ces points sont corrélés. J'ai déjà le code suivant:

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

Et cela fonctionne bien pour trouver tous les points à la circonférence du cercle, mais j'ai besoin de tous les points de n'importe où dans le cercle. Si cela n'a pas de sens, faites le moi savoir et je ferai de mon mieux pour clarifier.

Si vous voulez une solution simple, randomisez également le rayon:

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

Cela se traduit cependant par une concentration accrue de vos points vers le centre du cercle:

Afin d'obtenir une distribution uniforme, apportez la modification suivante à l'algorithme:

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

Ce qui donnera le résultat suivant:

Pour plus d'informations, consultez le lien suivant: MathWorld - Disk Point Picking .

Et enfin, voici une simple démonstration de JsFiddle comparant les deux versions de l'algorithme.

N'utilisez PAS seulement r et thêta aléatoires! Cela crée une distribution pondérée avec plus de points au centre. Cette page l'illustre bien ...

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

Voici la méthode qui crée une distribution non pondérée ...

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

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

Vous êtes à mi-chemin. En plus de générer un angle aléatoire, il suffit de générer une distance aléatoire, inférieure ou égale au rayon, pondérée pour obtenir une distribution 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);
}

Maintenant tu penses avec polar .

Vous pouvez également pondérer la distance comme ceci pour éviter une racine carrée:

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

Si les performances sont un problème, une solution alternative consiste à générer une position aléatoire dans une boîte avec la largeur / hauteur de votre cercle, puis à jeter tous les points qui ne sont pas dans la zone du cercle.

L'avantage de cette méthode est que vous n'effectuez aucune fonction cos / sin / sqrt, ce qui, selon votre plate-forme, peut représenter une économie de vitesse importante.

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

J'ai adopté l'approche de l'un des commentaires énumérés et étendu la fonctionnalité pour créer un système de génération de points en forme de beignet.

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

Il s'agit d'une approche similaire à celle mentionnée précédemment mais qui a donné des résultats différents. La partie intérieure du cercle sera laissée vierge sans point.