किनारों और आयतों का पता कैसे लगाएं

Question

मैं छवियों में आयतों का पता लगाने की कोशिश करता हूं। छवियों की पृष्ठभूमि एक रंग है (अधिकतर समय)। मैंने द्विआधारी छवि (1 = पृष्ठभूमि, 0 = किनारों) प्राप्त करने के लिए दो तरीकों की कोशिश की, बाद में एक परिवर्तन करने के लिए ...

1. सोबेल या कैनी फ़िल्टर

2. चिकनी छवि A, अंतर छवि A - गॉस बनाएं, दहलीज के साथ द्विआधारी छवि बनाएं (हिस्टोग्राम बनाएं, उच्चतम बिन पृष्ठभूमि होनी चाहिए ...)

परिणाम किनारों के साथ एक द्विआधारी छवि है। मैं वास्तव में अब नहीं है जो विधि विभिन्न छवियों की एक किस्म के लिए बेहतर काम करती है। कोई विचार?

Comments

"बेहतर काम करता है" से आपका क्या मतलब है? कैनी इस तरह की चीज के लिए बहुत लोकप्रिय है, लेकिन यह इस बात पर निर्भर करता है कि आप एक बार किनारों पर क्या करने की कोशिश कर रहे हैं। क्या आप प्राप्त करने की कोशिश कर रहे हैं, बिल्कुल?

— पॉल आर।

कृपया समुदाय पर अपने पहले प्रश्न के लिए नए उपयोगकर्ताओं को वोट न दें!

यह धागा उपयोगी हो सकता है- dsp.stackexchange.com/questions/2975/…

— जिम क्ले

एज डिटेक्टरों ने समझाया: dsp.stackexchange.com/q/74/1273

— पेनेलोप

"परिणाम किनारों के साथ एक द्विआधारी छवि है। मैं वास्तव में अब नहीं करता हूं कि कौन सी विधि विभिन्न छवियों की एक किस्म के लिए बेहतर काम करती है। किसी भी विचार?" हो सकता है कि आपको जवाब खोजने या वातावरण में कुछ तस्वीरें लेने के लिए कुछ छवि परीक्षण की आवश्यकता हो, जिसे आप शायद गिनते हैं। यदि इस क्षेत्र में सबसे अच्छा एल्गोरिदम मौजूद है, तो हमें दूसरों को इतना क्यों सीखना चाहिए? मेरा मानना ​​है कि किसी भी एल्गोरिदम का लाभ कभी-कभी, संभावित अर्थों में होता है।

Answer 1

मैंने एक बार आयत का पता लगाने के लिए एक आवेदन लिखा था। इसमें सोबेल एज डिटेक्शन और लाइन हूप ट्रांसफॉर्मेशन का इस्तेमाल किया गया था।

हफ़ इमेज (लाइनों) में एकल चोटियों की तलाश करने के बजाय, कार्यक्रम ने उनके बीच 90 डिग्री की दूरी के साथ 4 चोटियों की खोज की।

Hough image (कुछ कोण के अनुरूप) में प्रत्येक कॉलम के लिए, स्थानीय मैक्सीमा के लिए तीन अन्य कॉलम खोजे गए थे। जब चार स्तंभों में से प्रत्येक में satifactory शिखर पाया गया था, तो आयत का पता चला है।

कार्यक्रम ने आयत का निर्माण किया और झूठी सकारात्मकता का भेदभाव करने के लिए आयत के भीतर और बाहर रंग स्थिरता के लिए अतिरिक्त जांच की। कार्यक्रम कागज की स्कैन की गई शीट में पेपर प्लेसमेंट का पता लगाने के लिए था।

Answer 2

आप पा सकते हैं कि गॉसियन एज डिटेक्टर का लाप्लासियन एक बेहतर विकल्प है। यह आपको कैनी एज डिटेक्टर की तुलना में अधिक बार बंद होने वाले कॉन्टोज़ देना चाहिए। मेरा मानना ​​है कि आपके अगले कदम के बाद से आप जो चाहते हैं, वह है हूप ट्रांसफॉर्म को लागू करना।

Answer 3

हो सकता है कि आप इसके लिए सहायक हों, लेकिन इसके बहुत देर से आज मैं इस साइट पर जाता हूं

        Bitmap bmp=new Bitmap(pictureBox1.Image);
        int x1=0, x2=0, y1=0, y2=0;            
        for (int i = 1; i < bmp.Height;i++ )
        {                
            for (int j = 1; j < bmp.Width;j++ )
            {
                if( bmp.GetPixel(j,i).R<7  &&  bmp.GetPixel(j-1,i).R>240  && bmp.GetPixel(j,i-1).R>240 ){

                    for (int k = j; k < bmp.Width - 1;k++ )
                    {

                        if ((bmp.GetPixel(k, i).R < 7) && (bmp.GetPixel(k+1, i).R > 240) && (k-j>30)) {
                            int count1 = 0;

                            for (int g = j; g < k;g++ ){
                                if(bmp.GetPixel(g,i).R<7){
                                    count1++;                                    
                                }
                            }//get total width

                         if(count1==k-j){                                 
                             x1 = j;
                             y1 = i;
                             x2 = k;
                         }
                        }
                    }
                         for (int a = i; a < bmp.Height - 1;a++ )
                         {
                             if ((bmp.GetPixel(j, a).R < 7) && (bmp.GetPixel(j, a+1).R > 240) && (a- i > 30)) {

                                 int count2 = 0;

                                 for (int x = i; x < a;x++ )
                                 {
                                     if(bmp.GetPixel(j,x).R<7){                                            
                                         count2++;
                                     }
                                 }


                                 if (count2 == (a - i))
                                 {

                                     y2 = a;
                                 }
                                 else {
                                     Console.WriteLine("check");
                                 }
                             }

                         }

                         if ((bmp.GetPixel(x2, y2).R < 7) && (bmp.GetPixel(x2 + 1, y2).R > 240) && (bmp.GetPixel(x2, y2+1).R > 240))
                         {

                             bool r1 = false;
                             bool r2 = false;
                             int count3 = 0;
                             for (int y = y1; y < y2;y++ )
                             {
                                 if(bmp.GetPixel(x2,y).R<7){
                                     count3++;                                     
                                 }
                             }

                             if (count3== y2 - y1) {
                                 r1 = true;
                             }                                
                             if(r1==true){
                                 int count4=0;
                                 for (int x = x1; x < x2;x++ )
                                 {
                                     if(bmp.GetPixel(x,y1).R<7){
                                         count4++;
                                     }
                                 }

                                 if(count4==x2-x1){
                                     r2 = true;
                                     Console.WriteLine("values :  X1 " + x1 + "   y1 :" + y1 + "   width : " + (x2 - x1) + "  height :  " + (y2 - y1));
                                     Pen pen = new Pen(Color.Red, 2);
                                     pictureBox1.CreateGraphics().DrawRectangle(pen, x1, y1, x2 - x1, y2 - y1);
                                 }                     
                             }
                            }

                }

                    }// initial point loop




                }// first if

Comments

Dsp.stackexchange में आपका स्वागत है :) किसी भी उत्तर, यहां तक ​​कि एक देर से, बहुत स्वागत है, लेकिन यह अच्छा होगा यदि आप अपने उत्तर के साथ कुछ संदर्भ प्रदान करते हैं। उत्तर जो स्पष्टीकरण प्रदान करते हैं और स्रोत पसंद किए जाते हैं - क्या आप अपना उत्तर संपादित कर सकते हैं, कुछ वाक्य लिख सकते हैं कि कोड क्या करता है और यह पूछे जाने वाली समस्या के साथ कैसे मदद करेगा, और शायद स्रोत का हवाला दें यदि यह आप नहीं हैं? अगर आपका जवाब बहुत बेहतर होता। इसके अलावा, कृपया अपनी पहचान संपादित करें - मैंने कोशिश की है, लेकिन आपके एक तिहाई कोड से गुजरने के बाद मैं हार गया।

— पेनेलोप

Answer 4

यदि आपकी छवि अपेक्षाकृत साफ है, तो आपके पास स्पष्ट रूप से आयतें हैं जो बिना किसी बदलाव के विकल्प को तोड़ती हैं, ताकि वे एक 4 पक्षीय समोच्च = आपकी आयत बनाने के लिए आकृति बना सकें और उन्हें कम कर सकें।

ऐसा करने के लिए opencv नमूने हैं

Answer 5

पायथन ट्यूटोरियल आयतों को खरोंच से लिखा गया है। कैनी और हाफ लाइन्स का उपयोग करता है।