Équation pour tester si un point est à l’intérieur d’un cercle

Si vous avez un cercle avec le centre (center_x, center_y) et le rayon radius , comment testez-vous si un point donné avec les coordonnées (x, y) est à l’intérieur du cercle?

En général, x et y doivent satisfaire (x - center_x)^2 + (y - center_y)^2 < radius^2 .

Veuillez noter que les points qui satisfont à l'équation ci-dessus avec < remplacé par == sont considérés comme les points du cercle, et les points qui satisfont à l'équation ci-dessus avec < remplacé par > sont considérés comme extérieurs au cercle.

Mathématiquement, Pythagore est probablement une méthode simple, comme beaucoup l’ont déjà mentionné.

 (x-center_x)^2 + (y - center_y)^2 < radius^2 

Sur le plan informatique, il existe des moyens plus rapides. Définir:

 dx = abs(x-center_x) dy = abs(y-center_y) R = radius 

Si un point est plus susceptible de se trouver en dehors de ce cercle, imaginez un carré dessiné autour de lui de telle sorte que ses côtés soient tangents à ce cercle:

 if dx>R then return false. if dy>R then return false. 

Imaginez maintenant un losange carré dessiné à l'intérieur de ce cercle de telle sorte que ses sumts touchent ce cercle:

 if dx + dy <= R then return true. 

Maintenant, nous avons couvert la majeure partie de notre espace et seule une petite partie de ce cercle rest entre notre carré et le diamant à tester. Ici, nous revenons à Pythagore comme ci-dessus.

 if dx^2 + dy^2 <= R^2 then return true else return false. 

Si un point est plus susceptible d'être à l' intérieur de ce cercle, inversez l'ordre des trois premières étapes:

 if dx + dy <= R then return true. if dx > R then return false. if dy > R then return false. if dx^2 + dy^2 <= R^2 then return true else return false. 

Des méthodes alternatives imaginent un carré à l’intérieur de ce cercle au lieu d’un diamant mais cela nécessite un peu plus de tests et de calculs sans avantage de calcul (le carré intérieur et les diamants ont des zones identiques):

 k = R/sqrt(2) if dx <= k and dy <= k then return true. 

Mettre à jour:

Pour ceux qui s'intéressent à la performance, j'ai implémenté cette méthode dans c et compilé avec -O3.

J'ai obtenu des temps d'exécution à time ./a.out

J'ai implémenté cette méthode, une méthode normale et une méthode fictive pour déterminer le temps système.

Normal: 21.3s This: 19.1s Overhead: 16.5s

Il semble donc que cette méthode soit plus efficace dans cette implémentation.

 // comstack gcc -O3 .c // run: time ./a.out #include  #include  #define TRUE (0==0) #define FALSE (0==1) #define ABS(x) (((x)<0)?(0-(x)):(x)) int xo, yo, R; int inline inCircle( int x, int y ){ // 19.1, 19.1, 19.1 int dx = ABS(x-xo); if ( dx > R ) return FALSE; int dy = ABS(y-yo); if ( dy > R ) return FALSE; if ( dx+dy <= R ) return TRUE; return ( dx*dx + dy*dy <= R*R ); } int inline inCircleN( int x, int y ){ // 21.3, 21.1, 21.5 int dx = ABS(x-xo); int dy = ABS(y-yo); return ( dx*dx + dy*dy <= R*R ); } int inline dummy( int x, int y ){ // 16.6, 16.5, 16.4 int dx = ABS(x-xo); int dy = ABS(y-yo); return FALSE; } #define N 1000000000 int main(){ int x, y; xo = rand()%1000; yo = rand()%1000; R = 1; int n = 0; int c; for (c=0; c 

Vous pouvez utiliser Pythagoras pour mesurer la distance entre votre point et le centre et voir si elle est inférieure au rayon:

 def in_circle(center_x, center_y, radius, x, y): dist = math.sqrt((center_x - x) ** 2 + (center_y - y) ** 2) return dist <= radius 

EDIT (pointe du chapeau à Paul)

En pratique, la quadrature est souvent beaucoup moins chère que de prendre la racine carrée et comme nous ne sums intéressés que par un ordre, nous pouvons bien sûr renoncer à prendre la racine carrée:

 def in_circle(center_x, center_y, radius, x, y): square_dist = (center_x - x) ** 2 + (center_y - y) ** 2 return square_dist <= radius ** 2 

En outre, Jason a noté que <= devrait être remplacé par < et en fonction de l'utilisation, cela pourrait avoir du sens même si je crois que ce n'est pas vrai dans le ssortingct sens mathématique . Je me suis trompé.

 boolean isInRectangle(double centerX, double centerY, double radius, double x, double y) { return x >= centerX - radius && x <= centerX + radius && y >= centerY - radius && y <= centerY + radius; } //test if coordinate (x, y) is within a radius from coordinate (center_x, center_y) public boolean isPointInCircle(double centerX, double centerY, double radius, double x, double y) { if(isInRectangle(centerX, centerY, radius, x, y)) { double dx = centerX - x; double dy = centerY - y; dx *= dx; dy *= dy; double distanceSquared = dx + dy; double radiusSquared = radius * radius; return distanceSquared <= radiusSquared; } return false; } 

Ceci est plus efficace et lisible. Il évite l'opération de racine carrée coûteuse. J'ai également ajouté une vérification pour déterminer si le point se trouve dans le rectangle englobant du cercle.

La vérification du rectangle est inutile sauf avec de nombreux points ou de nombreux cercles. Si la plupart des points sont à l'intérieur des cercles, la vérification du rectangle englobant ralentira les choses!

Comme toujours, veillez à considérer votre cas d'utilisation.

Calculer la distance

 D = Math.Sqrt(Math.Pow(center_x - x, 2) + Math.Pow(center_y - y, 2)) return D <= radius 

c'est en C # ... convertir pour une utilisation en python ...

Vous devez vérifier si la distance entre le centre du cercle et le point est inférieure au rayon, c’est-à-dire

 if (x-center_x)**2 + (y-center_y)**2 <= radius**2: # inside circle 

Comme dit ci-dessus – utilisez la distance euclidienne.

 from math import hypot def in_radius(c_x, c_y, r, x, y): return math.hypot(c_x-x, c_y-y) <= r 

C’est la même solution que celle mentionnée par Jason Punyon , mais elle contient un exemple de pseudo-code et quelques détails supplémentaires. J’ai vu sa réponse après avoir écrit ceci, mais je ne voulais pas enlever le mien.

Je pense que le moyen le plus facile à comprendre consiste à calculer d’abord la distance entre le centre du cercle et le point. J’utiliserais cette formule:

 d = sqrt((circle_x - x)^2 + (circle_y - y)^2) 

Ensuite, comparez simplement le résultat de cette formule, la distance ( d ), avec le radius . Si la distance ( d ) est inférieure ou égale au rayon ( r ), le point est à l’intérieur du cercle (sur le bord du cercle si d et r sont égaux).

Voici un exemple de pseudo-code qui peut facilement être converti en n’importe quel langage de programmation:

 function is_in_circle(circle_x, circle_y, r, x, y) { d = sqrt((circle_x - x)^2 + (circle_y - y)^2); return d <= r; } 

circle_x et circle_y sont les coordonnées centrales du cercle, r est le rayon du cercle et x et y sont les coordonnées du point.

Trouvez la distance entre le centre du cercle et les points donnés. Si la distance entre eux est inférieure au rayon, le point est à l’intérieur du cercle. si la distance entre eux est égale au rayon du cercle, le point se trouve sur la circonférence du cercle. si la distance est supérieure au rayon, le point est en dehors du cercle.

 int d = r^2 - (center_x-x)^2 + (center_y-y)^2; if(d>0) print("inside"); else if(d==0) print("on the circumference"); else print("outside"); 

Ma réponse en C # en tant que solution complète de cut & paste (non optimisée):

 public static bool PointIsWithinCircle(double circleRadius, double circleCenterPointX, double circleCenterPointY, double pointToCheckX, double pointToCheckY) { return (Math.Pow(pointToCheckX - circleCenterPointX, 2) + Math.Pow(pointToCheckY - circleCenterPointY, 2)) < (Math.Pow(circleRadius, 2)); } 

Usage:

 if (!PointIsWithinCircle(3, 3, 3, .5, .5)) { } 

J’ai utilisé le code ci-dessous pour les débutants comme moi :).

classe publique incirkel {

 public static void main(Ssortingng[] args) { int x; int y; int middelx; int middely; int straal; { // Adjust the coordinates of x and yx = -1; y = -2; // Adjust the coordinates of the circle middelx = 9; middely = 9; straal = 10; { //When x,y is within the circle the message below will be printed if ((((middelx - x) * (middelx - x)) + ((middely - y) * (middely - y))) < (straal * straal)) { System.out.println("coordinaten x,y vallen binnen cirkel"); //When x,y is NOT within the circle the error message below will be printed } else { System.err.println("x,y coordinaten vallen helaas buiten de cirkel"); } } } }} 

Comme indiqué précédemment, pour montrer si le point est dans le cercle, nous pouvons utiliser le suivant

 if ((x-center_x)^2 + (y - center_y)^2 < radius^2) { in.circle <- "True" } else { in.circle <- "False" } 

Pour le représenter graphiquement, nous pouvons utiliser:

 plot(x, y, asp = 1, xlim = c(-1, 1), ylim = c(-1, 1), col = ifelse((x-center_x)^2 + (y - center_y)^2 < radius^2,'green','red')) draw.circle(0, 0, 1, nv = 1000, border = NULL, col = NA, lty = 1, lwd = 1) 

Se déplacer dans le monde de la 3D si vous voulez vérifier si un point 3D se trouve dans une sphère d’unité, vous finissez par faire quelque chose de similaire. Il suffit d’utiliser les opérations vectorielles 2D pour travailler en 2D.

  public static bool Intersects(Vector3 point, Vector3 center, float radius) { Vector3 displacementToCenter = point - center; float radiusSqr = radius * radius; bool intersects = displacementToCenter.magnitude < radiusSqr; return intersects; }