Como detectar arestas e retângulos

Eu tento detectar retângulos em imagens. O fundo das imagens é de uma cor (na maioria das vezes). Eu tentei dois métodos para obter uma imagem binária (1 = fundo, 0 = bordas), para fazer uma transformação Hough mais tarde ...

1. Filtro Sobel ou Canny

2. Imagem suave A, Criar imagem de diferença A - gauss, Criar imagem binária com limite (Criar Histograma, a posição mais alta deve estar em segundo plano ...)

O resultado é uma imagem binária com bordas. Agora, não sei exatamente qual método funciona melhor para uma variedade de imagens diferentes. Alguma ideia?

Certa vez, escrevi um aplicativo para detecção de retângulos. Utilizou a detecção de borda de Sobel e a transformação de linha Hough.

Em vez de procurar picos únicos na imagem Hough (linhas), o programa pesquisou 4 picos com distância de 90 graus entre eles.

Para cada coluna na imagem Hough (correspondente a algum ângulo), outras três colunas foram pesquisadas para o máximo local. Quando o pico satifativo foi encontrado em cada uma das quatro colunas, o retângulo foi detectado.

O programa construiu o retângulo e fez verificações adicionais quanto à consistência das cores dentro e fora do retângulo para discriminar falsos positivos. O programa era para detectar a colocação de papel em folhas de papel digitalizadas.

Você pode achar que o detector de borda Laplaciano de Gaussiano é uma escolha melhor. Ele deve fornecer contornos fechados com mais frequência do que o detector de borda Canny. Acredito que é isso que você deseja, pois seu próximo passo é aplicar a transformação Hough.

Pode ser útil para você, mas é tarde demais quando eu visito este site hoje

        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

Se sua imagem estiver relativamente limpa, você terá retângulos óbvios sem muitas quebras, a alternativa para uma transformação de Hough é criar contornos e reduzi-los até formarem um contorno de 4 lados = seu retângulo.

Existem amostras opencv para fazer isso

Tutorial do Python para encontrar retângulos escritos do zero. Usa Canny e Hough Lines.