algorithm - houghlines - Detección de elipse usando Hough Transform

matlab hough-transform

Question

Usando Hough Transform, ¿cómo puedo detectar y obtener coordenadas de (x0, y0) y "a" y "b" de una elipse en el espacio 2D?

Esto es ellipse01.bmp:

I = imread(''ellipse01.bmp'');
[m n] = size(I);
c=0;
for i=1:m
for j=1:n
if I(i,j)==1
c=c+1;
p(c,1)=i;
p(c,2)=j;
end
end
end
Edges=transpose(p);
Size_Ellipse = size(Edges);
B = 1:ceil(Size_Ellipse(1)/2);
Acc = zeros(length(B),1);
a1=0;a2=0;b1=0;b2=0;
Ellipse_Minor=[];Ellipse_Major=[];Ellipse_X0 = [];Ellipse_Y0 = [];
Global_Threshold = ceil(Size_Ellipse(2)/6);%Used for Major Axis Comparison
Local_Threshold = ceil(Size_Ellipse(1)/25);%Used for Minor Axis Comparison
[Y,X]=find(Edges);
Limit=numel(Y);
Thresh = 150;
Para=[];
for Count_01 =1:(Limit-1)
for Count_02 =(Count_01+1):Limit
if ((Count_02>Limit) || (Count_01>Limit))
continue
end
a1=Y(Count_01);b1=X(Count_01);
a2=Y(Count_02);b2=X(Count_02);
Dist_01 = (sqrt((a1-a2)^2+(b1-b2)^2));
if (Dist_01 >Global_Threshold)
Center_X0 = (b1+b2)/2;Center_Y0 = (a1+a2)/2;
Major = Dist_01/2.0;Alpha = atan((a2-a1)/(b2-b1));
if(Alpha == 0)
for Count_03 = 1:Limit
if( (Count_03 ~= Count_01) || (Count_03 ~= Count_02))
a3=Y(Count_03);b3=X(Count_03);
Dist_02 = (sqrt((a3 - Center_Y0)^2+(b3 - Center_X0)^2));
if(Dist_02 > Local_Threshold)
Cos_Tau = ((Major)^2 + (Dist_02)^2 - (a3-a2)^2 - (b3-b2)^2)/(2*Major*Dist_02);
Sin_Tau = 1 - (Cos_Tau)^2;
Minor_Temp = ((Major*Dist_02*Sin_Tau)^2)/(Major^2 - ((Dist_02*Cos_Tau)^2));
if((Minor_Temp>1) && (Minor_Temp<B(end)))
Acc(round(Minor_Temp)) = Acc(round(Minor_Temp))+1;
end
end
end
end
end
Minor = find(Acc == max(Acc(:)));
if(Acc(Minor)>Thresh)
Ellipse_Minor(end+1)=Minor(1);Ellipse_Major(end+1)=Major;
Ellipse_X0(end+1) = Center_X0;Ellipse_Y0(end+1) = Center_Y0;
for Count = 1:numel(X)
Para_X = ((X(Count)-Ellipse_X0(end))^2)/(Ellipse_Major(end)^2);
Para_Y = ((Y(Count)-Ellipse_Y0(end))^2)/(Ellipse_Minor(end)^2);
if (((Para_X + Para_Y)>=-2)&&((Para_X + Para_Y)<=2))
Edges(X(Count),Y(Count))=0;
end
end
end
Acc = zeros(size(Acc));
end
end
end

Answer 1

Si usa el círculo para la transformación aproximada se da como rho = xcos (theta) + y sin (theta) Para la elipse ya que es

Podrías transformar la ecuación como rho = a x cos (theta) + b y sin (theta) Aunque no estoy seguro de si usas la Transformada Hough estándar, para las transformaciones tipo elipse, podrías manipular la primera función dada.

Answer 2

Si conoce la ''a'' y la ''b'' de una elipse, puede cambiar la escala de la imagen por factor de a / b en una dirección y buscar el círculo. Todavía estoy pensando qué hacer cuando a y b son desconocidos.

Si sabes que es un círculo, utiliza la transformación Hough para círculos. Aquí hay un código de muestra:

int accomulatorResolution = 1; // for each pixel
int minDistBetweenCircles = 10; // In pixels
int cannyThresh = 20;
int accomulatorThresh = 5*_accT+1;
int minCircleRadius = 0;
int maxCircleRadius = _maxR*10;
cvClearMemStorage(storage);
circles = cvHoughCircles( gryImage, storage,
CV_HOUGH_GRADIENT, accomulatorResolution,
minDistBetweenCircles,
cannyThresh , accomulatorThresh,
minCircleRadius,maxCircleRadius );
// Draw circles
for (int i = 0; i < circles->total; i++){
float* p = (float*)cvGetSeqElem(circles,i);
// Draw center
cvCircle(dstImage, cvPoint(cvRound(p[0]),cvRound(p[1])),
1, CV_RGB(0,255,0), -1, 8, 0 );
// Draw circle
cvCircle(dstImage, cvPoint(cvRound(p[0]),cvRound(p[1])),
cvRound(p[2]),CV_RGB(255,0,0), 1, 8, 0 );
} 

Answer 3

Si su elipse es como se proporciona, siendo una verdadera elipse y no una muestra ruidosa de puntos; la búsqueda de los dos puntos más lejanos da los extremos del eje mayor, la búsqueda de los dos puntos más cercanos da los extremos del eje menor, la intersección de estas líneas (puede verificar que es un ángulo recto) ocurre en el centro.

Answer 4

Aunque esta es una vieja pregunta, tal vez lo que encontré puede ayudar a alguien.

El principal problema de usar la Transformada Hough normal para detectar elipses es la dimensión del acumulador, ya que tendríamos que votar por 5 variables (la ecuación se explica aquí ):

Hay un algoritmo muy bueno en el que el acumulador puede ser una matriz 1D simple, por ejemplo, y que se ejecuta en . Si quieres ver el código, puedes mirarlo aquí (la imagen utilizada para probar fue la publicada anteriormente).