Ellipse de Détection à l'aide de Transformation de Hough

à l'aide de Hough Transformer, comment puis-je détecter et d'obtenir les coordonnées de (x0,y0) et "a" et "b" d'une ellipse dans l'espace 2D?

C'est 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

?en.wikipedia.org/wiki/...
J'ai essayé de mettre en œuvre cet algorithme avec MATLAB, mais il ne fonctionne pas correctement. Je crois que je n'ai pas la mettre en œuvre correctement. Veuillez passer en revue la question de nouveau.
Cette mise en œuvre est coppied à partir de en.wikipedia.org/wiki/Hough_transform#

OriginalL'auteur Ata | 2011-06-10

2

Si vous utilisez cercle bruts de transformation est donné à titre rho = xcos(theta) + ysin(thêta)
Pour l'ellipse, car il est

Vous pourriez transformer l'équation
rho = unxcos(theta) + bysin(thêta)
Bien que je ne suis pas sûr si vous utilisez la norme Hough Transformer, par ellipse comme les transforme, vous pouvez manipuler la première fonction donnée.

Comme vous le savez, nous avons une image dans laquelle il y a juste une ellipse, sans aucune information. ( nous ne savons pas "a","b" et "(x0,y0)" ). nous devrions utiliser Hough transformer afin de déterminer ces paramètres.

OriginalL'auteur Hephaestus
1

Bien que c'est une vieille question, peut-être ce que j'ai trouvé peut aider quelqu'un.

Le principal problème de l'utilisation normale de Hough Transformer pour détecter des ellipses est la dimension de l'accumulateur, car nous aurions besoin de vote pour les 5 variables (l'équation est expliqué ici):

$Ellipse de Détection à l'aide de Transformation de Hough$

Il y a une très belle algorithme où l'accumulateur peut être une simple 1D tableau, par exemple, et qui s'exécute dans $Ellipse de Détection à l'aide de Transformation de Hough$ . Si vous voulez voir le code, vous pouvez regarder ici (l'image utilisée pour les essais, qui ont affiché ci-dessus).

OriginalL'auteur boechat107
1

Si votre ellipse, comme prévu, avec une ellipse et non un bruyant échantillon de points;
la recherche des deux points les plus éloignés donne les extrémités de l'axe majeur,
la recherche pour les deux plus proche des points aux extrémités de l'axe mineur,
l'intersection de ces lignes (vous pouvez vérifier, c'est un angle droit) se produit au centre.

OriginalL'auteur user5852782

Si vous connaissez le " a " et " b " d'une ellipse, alors vous pouvez redimensionner l'image par un facteur de a/b dans une direction et de regarder pour le cercle. Je pense encore que faire lorsque a et b sont inconnus.

Si vous savez que c'est le cercle puis utiliser la transformation de Hough pour les cercles. Voici un exemple de code:

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 );
}

En fait, nous ne savons pas 'a' et 'b'. mais pour l'instant, permet de supposer que c'est un cercle (a=b). l'algorithme que nous devons suivre pour déterminer le Rayon et (x0,y0)?
J'ai ajouté un exemple de code dans ma réponse précédente

OriginalL'auteur DanielHsH

Vous devez vous connecter pour publier un commentaire.