हौ ट्रांसफॉर्म का उपयोग करके हफ़ ट्रांसफॉर्म

Question

का उपयोग करके एलिप्स डिटेक्शन, मैं 2 डी स्पेस में एक अंडाकार के (x0, y0) और "a" और "b" के समन्वय का पता कैसे लगा सकता हूं?

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

आप किसी न किसी के लिए चक्र का उपयोग करते हैं बदलने रो = एक्स cos (थीटा) + y पाप (थीटा) अंडाकार के लिए दिया जाता है:

यह ellipse01.bmp है चूंकि यह

आप समीकरण को rho = a x के रूप में बदल सकते हैं कॉस (थेटा) + बी वाई पाप (थेटा) हालांकि मुझे यकीन नहीं है कि क्या आप मानक हफ़ ट्रांसफॉर्म का उपयोग करते हैं, तो एलीप्स-जैसे ट्रांसफॉर्म के लिए, आप पहले दिए गए फ़ंक्शन में हेरफेर कर सकते हैं।

Answer 2

यदि आप एक अंडाकार के 'ए' और 'बी' को जानते हैं तो आप एक दिशा में ए/बी के कारक द्वारा छवि को पुन: सहेज सकते हैं और सर्कल की तलाश कर सकते हैं। मैं अभी भी सोच रहा हूं कि ए और बी अज्ञात होने पर क्या करना है।

यदि आप जानते हैं कि यह सर्कल है तो सर्कल के लिए हफ़ ट्रांसफॉर्म का उपयोग करें। यहां एक नमूना कोड है:

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

हालांकि यह एक पुराना सवाल है, शायद जो मैंने पाया वह किसी की मदद कर सकता है।

वहाँ: के बाद से हम (समीकरण here समझाया गया है) 5 चर के लिए वोट करने के लिए की आवश्यकता होगी

सामान्य Hough दीर्घवृत्त का पता लगाने के रूपांतरण का उपयोग करने का मुख्य समस्या यह है, संचायक के आयाम है एक बहुत अच्छा algorithm है जहां संचयक एक साधारण 1 डी सरणी हो सकता है, उदाहरण के लिए, और यह में चलता है। यदि आप कोड देखना चाहते हैं, तो आप here देख सकते हैं (परीक्षण करने के लिए उपयोग की गई छवि ऊपर पोस्ट की गई थी)।

Answer 4

यदि आपका अंडाकार प्रदान किया गया है, तो एक वास्तविक अंडाकार होना और बिंदुओं का शोर नमूना नहीं होना; दो सबसे दूर के बिंदुओं की खोज प्रमुख धुरी के सिरों को देती है, दो निकटतम बिंदुओं की खोज नाबालिग धुरी के सिरों को देती है, इन पंक्तियों के चौराहे (आप इसे सही कोण देख सकते हैं) पर होती है केंद्र।