Determining whether a array of points roughly make a circle

Question

Me and my friend spent an hour or two in making a code in java to find whether an array of points represented by x[] (for x coordinates) and y[] (for y coordinates) roughly form a circle or not.

We have done a lot of research but every time we end up solving very large simultaneous equations in 3 variables.

What we were thinking is to take first 3 points of the array and find the center (circum centre) of these 3 points then we can find the radius of the circle made by these 3 points and if other points also satisfy the distance form the center is roughly equal to radius then we have a circle.

How can we do this?

Answer 1

"How can we do this?"

Basically, by doing a bit of maths.

Assume you have N points P₁ through P_n.

1. Pick a pair of points P₁ and P₂.
2. Find the midpoint M₁ of the line L₁ between the points P₁ and P₂.
3. Construct another line R₁ at right-angles to L₁ passing through M₁.
4. Repeat steps 1 through 3 for points P₂ and P₃ to give you a second line R₂.
5. Find the point of intersection of R₁ and R₂. That is the candidate center C of the circle.
6. For each point P_i, calculate the distance from C to P_i.

If your points are "roughly" in a circle, then distances from each point to the center will be "roughly" the same.

Steps 1 through 6 can be turned into analytic formulae with some simple algebra. Work out the formulae, then turn them into code.

Answer 2

This is a potential O(n) solution that I believe works. It uses the simple 2D circle equation: x^2 + y^2 = r^2. I haven’t actually tested it, so take it with a grain of salt.

Also, you haven’t laid out all the assumptions in your problem. Is the relationship between x and y one-to-one? What about the order of elements? Are they of the same length? What does roughly mean?

Assuming that x and y are integer arrays of same length with ordered one-to-one mapping, you can loop through x and y and make a new array with x^2 + y^2 values. Let’s call this new array r2.

Now is the time I have to define “roughly”. Let’s suppose if all the values of r2 are equal with an acceptable offset of delta = 10, we have a circle. You can choose any arbitrary value for delta to fit your definition of a rough circle.

In pseudocode, it will look like this:

delta = 10;
r2 = [];
for i = 0 to length(x) {
    r2.append(x[i] * x[i] + y[i] * y[i]);
}

random_r2_value = r2(randomInt(0, length(r2));
upper_bound = random_r2_value + delta;
lower_bound = random_r2_value - delta;

isCircle = true;

for value in r2 {
    if value >= lower_bound && value <= upper_bound {
    // yay
    continue;
    } else {
        isCircle = false;
        break;
    }
}

print(isCircle)

And you can combine the two loops using a greedy method if you wanted to.

Good luck!

Answer 3

So I played around in Python (just cause it is easiest for me to quickly prototype the solution) and came up with this:

from collections import namedtuple
from math import sqrt
from statistics import mean

Point = namedtuple('Point', ['x', 'y'])

def length_between_points(a: Point, b: Point):
    squared = (pow(a.x - b.x, 2) + pow(a.y - b.y, 2))
    return sqrt(squared)

def normalize(raw):
    return [float(i)/max(raw) for i in raw]

def is_roughly_circle(x, y, confidence=0.1):
    center = Point(x=mean(x), y=mean(y))
    points = [Point(x[i], y[i]) for i in range(len(x))]

    lengths_from_center = [length_between_points(p, center) for p in points]
    normalized = normalize(lengths_from_center)
    is_circle = all([length > 1 - confidence for length in normalized])
    return is_circle


x = [1, 2, 3, 4, 5]
y = [1, 2, 3, 4, 5]
print(is_roughly_circle(x, y)) # False

x = [0, 1, 0, -1]
y = [1, 0, -1, 0]
print(is_roughly_circle(x, y)) # True

x = [0, 1.1, 0, -1]
y = [1, 0, -1, 0]
print(is_roughly_circle(x, y)) # True

x = [0, 1.2, 0, -1]
y = [1, 0, -1, 0]
print(is_roughly_circle(x, y)) # False

x = [0, 1.2, 0, -1]
y = [1, 0, -1, 0]
print(is_roughly_circle(x, y, confidence=0.2)) # True

Assumptions:

1. It is better to calculate center of all points, not only the first 3. It is not the most optimal, but handles the case, if the first point from input is in the geometrical center.
2. Ovals and ellipsis are not a 'roughly circle'
3. How 'Rough' the circle can be could be set with confidence parameter [0,1)

Algorithm:

1. Calculate the mean of all the points (center)
2. Calculate distance from the center for all the points
3. Normalize the distances to the range [0,1]
4. Are all values in the normalized vector greater than 0.9?
5. If so, the set of points is a circle with confidence of 0.1.