So passen Sie eine Ellipse an 2D-Daten an

Ich möchte die "beste" Anpassung einer Ellipse an zusammenhängende, möglicherweise konkave Formen finden, wie:

Was habe ich versucht?

Ich dachte, man könnte die Richtung der Haupt- und Nebenachse zuweisen $\vec a, \vec b$der Ellipse durch Abbildung der Pixelwerte auf Koordinaten, Mittelwert subtrahieren und Speichern der beiden größten Eigenvektoren von einer PCA. Das scheint ziemlich gut zu funktionieren, um die Richtung zu finden:

Mein Problem ist die Bestimmung der Länge dieser beiden Vektoren. Im Moment habe ich verwendet$\sqrt \lambda_1$ $\sqrt \lambda_2$aus den Eigenwerten der PCA. Dies scheint die Länge zu unterschätzen. Wie kann ich feststellen$|\vec a|$, und $|\vec b|$ oder alternativ am besten eine Ellipse an diese Formen anpassen?

Weiterverfolgung meiner gelöschten Antwort ... Wenn Sie eine gefüllte Ellipse nehmen und alle Punkte auf die projizieren $x$Achse werden mehr Punkte in der Nähe des Ursprungs als auf den Extremen in einer kreisförmigen Verteilung projiziert. Keine Gaußsche Verteilung und nicht die gleichmäßige Verteilung, die ich in meiner gelöschten Antwort in der 1-D-Analogie erwähnt habe. Die resultierende Distribution hat tatsächlich PDF$p(x) = \sqrt{(1 - (\frac{x}{r})^2)}$und von dort aus können Sie berechnen, dass die Standardabweichung ist $\frac{r}{2}$.

Wenn also Daten im Inneren einer Radienellipse gleichmäßig verteilt sind $a, b$ (deren Achsen sind die $x$ und $y$ Achsen), die Standardabweichung der $x$ Koordinate ist $\frac{a}{2}$ und von der $y$ Koordinate ist $\frac{b}{2}$. Der zu verwendende Korrekturfaktor ist also einfach 2.

Hier ist ein Beispiel in Python, das das Zentrum (Translationsmatrix), die Rotationsmatrix und die Radien einer Ellipse aus Punkten wiederherstellt, die zufällig aus ihrem Inneren entnommen wurden:

import numpy

# Generate some points distributed uniformely along an ellipse
x = 2 * (numpy.random.rand(10000, 1) - 0.5)
y = 2 * (numpy.random.rand(10000, 1) - 0.5)
d = (x / 0.5) ** 2 + (y / 0.25) ** 2
inside = numpy.where(d < 1)[0]
x = x[inside]
y = y[inside]
data = numpy.hstack((x, y)).T

# Now rotate by 0.5 rad and translate it to (4, -8)
angle = 0.5
rotation = numpy.array([
    [numpy.cos(0.4), -numpy.sin(0.4)],
    [numpy.sin(0.4), numpy.cos(0.4)]])

data = numpy.dot(rotation, data)
data[0, :] += 4
data[1, :] -= 8

# Step 1: center the data to get the translation vector.
print 'Translation', data.mean(axis=1)
data -= numpy.reshape(data.mean(axis=1), (2, 1))

# Step 2: perform PCA to find rotation matrix.
scatter = numpy.dot(data, data.T)
eigenvalues, transform = numpy.linalg.eig(scatter)
print 'Rotation matrix', transform

# Step 3: Rotate back the data and compute radii.
# You can also get the radii from smaller to bigger
# with 2 / numpy.sqrt(eigenvalues)
rotated = numpy.dot(numpy.linalg.inv(transform), data)
print 'Radii', 2 * rotated.std(axis=1)

Überprüfen Sie die Anpassung der Ellipsen durch die kleinsten Quadrate von Fitzgibbon et al. Es ist ein einfaches Eigenwertproblem, dessen Größe nicht proportional zur Anzahl der Pixel in Ihrer Stichprobe ist! Der einzige Schritt, der von der Anzahl der Pixel abhängt, die Sie darauf werfen, ist die Berechnung einer Streumatrix, die noch vorhanden ist$O(n)$.