Kenarları ve dikdörtgenleri algılama

Görüntülerdeki dikdörtgenleri tespit etmeye çalışıyorum. Görüntülerin arka planı bir renktir (çoğu zaman). Daha sonra bir Hough Dönüşümü yapmak için ikili bir görüntü (1 = arka plan, 0 = kenarlar) almak için iki yöntem denedim ...

1. Sobel veya Canny Filtresi

2. Düzgün görüntü A, Fark görüntü oluştur A - gauss, Eşikle ikili görüntü oluştur (Histogram Oluştur, en yüksek bölme arka plan olmalıdır ...)

Sonuç, kenarları olan bir ikili görüntüdür. Şu an hangi yöntemin çeşitli görüntüler için daha iyi çalıştığını bilmiyorum. Herhangi bir fikir?

Bir keresinde dikdörtgen tespiti için bir uygulama yazdım. Sobel kenar algılama ve hat Hough dönüşümü kullandı.

Program, Hough görüntüsünde (satırlar) tekli tepe noktaları aramak yerine, aralarında 90 derecelik bir mesafeye sahip 4 tepe noktası aradı.

Hough görüntüsündeki (bir açıya karşılık gelen) her sütun için, diğer üç sütun yerel maksima için aranmıştır. Dört sütunun her birinde doyurucu pik bulunduğunda, dikdörtgen tespit edilmiştir.

Program dikdörtgeni oluşturdu ve yanlış pozitifleri ayırt etmek için dikdörtgenin içinde ve dışındaki renk tutarlılığını kontrol etti. Program taranan kağıtlara kağıt yerleşimini tespit etmekti.

Gauss kenar dedektörü Laplacian'ın daha iyi bir seçim olduğunu görebilirsiniz. Size Canny kenar dedektöründen daha sık kapalı konturlar vermelidir. Bir sonraki adımınız Hough dönüşümünü uygulamak olduğu için istediğiniz şey olduğuna inanıyorum.

Sizin için yararlı olabilir ama bugün bu siteyi ziyaret ederken çok geç

        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

Resminiz nispeten temizse, çok fazla ara vermeden belirgin dikdörtgenleriniz var Hough dönüşümünün alternatifi, konturlar oluşturmak ve 4 taraflı bir kontur = dikdörtgeni oluşturana kadar bunları azaltmaktır.

Bunu yapmak için opencv örnekleri var

Python Dikdörtgenleri bulmak için öğretici Sıfırdan yazılmıştır. Canny ve Hough Hatlarını kullanır.