Oblicz losowe punkty (piksel) w okręgu (obraz)

Mam obraz, który zawiera koła w określonym miejscu i o określonej średnicy. Muszę tylko obliczyć losowe punkty w okręgu, a następnie manipulować pikselami, z którymi te punkty się korelują. Mam już następujący kod:

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

I to działa dobrze, aby znaleźć wszystkie punkty na obwodzie koła, ale potrzebuję wszystkich punktów z dowolnego miejsca w okręgu. Jeśli to nie ma sensu, daj mi znać, a ja postaram się wyjaśnić.

Jeśli chcesz prostego rozwiązania, po prostu losuj również promień:

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

To jednak powoduje, że twoje punkty są bardziej skoncentrowane w kierunku środka koła:

Aby uzyskać jednolity rozkład, wprowadź następującą zmianę w algorytmie:

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

Co da następujący wynik:

Aby uzyskać więcej informacji, sprawdź następujący link: MathWorld - Wybór punktu dysku .

I w końcu oto prosta demonstracja JsFiddle porównująca obie wersje algorytmu.

NIE używaj po prostu losowego r i theta! Tworzy to rozkład ważony z większą liczbą punktów w środku. Ta strona dobrze to ilustruje ...

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

Oto metoda, która tworzy nieważony rozkład ...

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

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

Jesteś w połowie drogi. Oprócz generowania losowego kąta, po prostu wygeneruj losową odległość, mniejszą lub równą promieniu, ważoną, aby uzyskać jednolity rozkład:

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

Teraz myślisz z biegunem .

Możesz także zważyć taką odległość, aby uniknąć pierwiastka kwadratowego:

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

Jeśli wydajność stanowi problem, jednym z alternatywnych rozwiązań jest wygenerowanie losowej pozycji w polu o szerokości / wysokości koła, a następnie wyrzucenie punktów, które nie znajdują się w obszarze koła.

Zaletą tej metody jest brak wykonywania funkcji cos / sin / sqrt, co w zależności od platformy może być dużą oszczędnością prędkości.

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

Przyjąłem podejście do jednego z wymienionych komentarzy i rozszerzyłem funkcjonalność o system generowania punktów w kształcie pączka.

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

Jest to podobne podejście, jak wspomniano wcześniej, ale zapewniło inne wyniki. Wewnętrzna część koła pozostanie pusta bez punktów.