Trouver tous les points à l'intérieur d'un cercle dans l'espace 2D

Il va servir mon but?

Pour votre 100x100, oui.

Puis-je le rendre plus rapide?

Oui. Par exemple, vous pouvez:

• Case à seulement 1 quadrant et d'obtenir d'autres points à cause de la symétrie.
• Ignorer la racine carrée lors du calcul de la distance.

Code:

for (x = xCenter - radius ; x <= xCenter; x++)
{
    for (y = yCenter - radius ; y <= yCenter; y++)
    {
        //we don't have to take the square root, it's slow
        if ((x - xCenter)*(x - xCenter) + (y - yCenter)*(y - yCenter) <= r*r) 
        {
            xSym = xCenter - (x - xCenter);
            ySym = yCenter - (y - yCenter);
            //(x, y), (x, ySym), (xSym , y), (xSym, ySym) are in the circle
        }
    }
}

C'est à propos de 4x vitesse.

JS tests pour les solutions présentées ici. La symétrie est la manière la plus rapide sur mon ordinateur. Trigonométrie présenté par le Niet de l'Obscurité Absol est très intelligent, mais il implique cher fonctions mathématiques comme sin et acos, qui ont un impact négatif sur les performances.

Vous pouvez obtenir la vitesse de l'onduleur par l'informatique autant en dehors de la boucle que possible. Aussi il n'y a pas besoin de faire le Théorème de Pythagore racine carrée... il suffit de garder tout au carré. Une vitesse finale peut être faite seulement par les de faire le calcul pour un quart de cercle (parce que c'est symétrique)... quand une correspondance est trouvée, vous venez de le reproduire pour les trois autres trimestres.

radiusSquared = radius*radius;
rightEdge = centerX+radius;
bottomEdge = centerY+radius;
for(x = centerX; x <= rightEdge; x++){
    xSquared = x*x;
    for(y = centerY; y <= bottomEdge; y++){
        ySquared = y*y;
        distSquared = xSquared+ySquared;
        if(distSquared <= radiusSquared){
            //Get positions for the other quadrants.
            otherX = centerX-(x-centerX);
            otherY = centerY-(y-centerY);
            //Do something for all four quadrants.
            doSomething(x, y);
            doSomething(x, otherY);
            doSomething(otherX, y);
            doSomething(otherX, otherY);
        }
    }
}

semble correcte. vous pouvez la rendre un peu plus rapide par trouver minY et ensuite de faire DoSomething de -rangeY à +rangeY pour le courant X.

for(dx=0;dx<rad; dx++)
{
  rangeY = 0;
  while (!inside(x, rangeY)) //inside == check if x*x + y*y <r*r
    rangeY++;

  for(y=center-rangeY;y<center+rangeY;y++) 
  {
    DoSomething(centerX - dx, y);
    DoSomething(centerX + dx, y);      }
}

Je sais que cette question a accepté de répondre, mais j'ai un beaucoup plus facile solution. Les autres réponses qui me confond, comme je ne sais pas ce center, xcenter, ycenter ont été, et les mathématiques derrière les fonctions étaient de gauche inexpliquée et j'ai parcouru à la découverte d'une solution mathématique de mon propre.

Mon équation est très simple:

cx est le point x du centre du cercle

cy est le point y du centre du cercle

rad est le rayon du cercle

Ce que mon équation/fonction n'est de calculer les points en calculant pour chaque point, étant donné le rayon et il ajoute et soustrait l'offset de cx et cy.

//Creates an array filled with numbers
function range(begin, end) {
    for (var i = begin, arr = []; i < end; i++) {
      arr.push(i);
    }

    return arr;
}

function calculateAllPointsInCircle(cx, cy, rad) {

   var rang = range(-rad, rad + 1);
   var px = [];
   var py = [];
   var xy = [];

   for (var i = 0; i < rang.length; i++) {
     var x = cx + rang[i];
     px.push(x);

     for (var l - rang.length - 1; l > 0; l--) {
        var y = cy + rang[l];
        if (!py.indexOf(y)===-1) { py.push(y); }

        xy.push(x+','+y);
     }
   }

   return {
     x: x,
     y: y,
     xy: xy
   }
}

Le rendement est beaucoup plus élevé que les autres réponses: http://jsperf.com/point-in-circle/4
Vous pouvez consulter mon équation avec les mathématiques, à l'aide de l'équation qui permettra de valider si un point est à l'intérieur d'un cercle x*x + y*y <= r*r OU x^2 + y^2 <= r^2

Edit - Super compressé ES6 version:

function range(begin, end) {
  for (let i = begin; i < end; ++i) {
    yield i;
  }
}

function calculateAllPointsInCircle(cx, cy, rad) {
    return {
        x: [cx + i for (i of range(-rad, rad + 1))],
        y: [cy + i for (i of range(-rad, rad + 1))]
    };
}